API Models

Requests

class kelvin.api.client.model.requests.AppVersionCreate(**kwargs)

AppVersionCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionPatch(**kwargs)

AppVersionPatch object.

Parameters:

• schemas (Schemas | None) – Optional[manifest.Schemas]

• defaults (Defaults | None) – Optional[manifest.Defaults]

• kwargs (Any)

schemas: manifest.Schemas | None

defaults: manifest.Defaults | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionUpdate(**kwargs)

AppVersionUpdate object.

Parameters:

• schemas (Schemas | None) – Optional[manifest.Schemas]

• defaults (Defaults | None) – Optional[manifest.Defaults]

• kwargs (Any)

schemas: manifest.Schemas | None

defaults: manifest.Defaults | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Runtime(**kwargs)

Runtime object.

Parameters:

• custom_actions (list[CustomAction] | None) – Optional[list[manifest.CustomAction]]

• resources (list[Resource] | None)

• configuration (dict[str, Any] | None)

• kwargs (Any)

custom_actions: list[manifest.CustomAction] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Deployment(**kwargs)

Deployment object.

Parameters:

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• max_resources (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• target (DeploymentTarget | None) – Optional[manifest.DeploymentTarget]

• workload_name_template (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

deployment_type: enum.DeploymentType | None

max_resources: StrictInt | None

target: manifest.DeploymentTarget | None

workload_name_template: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionDeploy(**kwargs)

AppVersionDeploy object.

Parameters:

• runtime (Runtime | None) – Optional[Runtime]

• system (System | None) – Optional[manifest.System]

• deployment (Deployment | None) – Optional[Deployment]

• kwargs (Any)

runtime: Runtime | None

system: manifest.System | None

deployment: Deployment | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppResourcesEnable(**kwargs)

AppResourcesEnable object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppResourcesDisable(**kwargs)

AppResourcesDisable object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppResourcesDelete(**kwargs)

AppResourcesDelete object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppPatch(**kwargs)

AppPatch object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• category (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

category: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppsContextList(**kwargs)

AppsContextList object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

sources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParameterValuesList(**kwargs)

AppVersionParameterValuesList object.

Parameters:

• apps (list[App] | None)

• resources (list[KRN] | None)

• parameter_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParametersHistoryList(**kwargs)

AppVersionParametersHistoryList object.

Parameters:

• start_date (datetime | None) – Optional[datetime]

• end_date (datetime | None) – Optional[datetime]

• apps (list[App] | None)

• resources (list[KRN] | None)

• parameter_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

start_date: datetime | None

end_date: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppParametersList(**kwargs)

AppParametersList object.

Parameters:

• app_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• data_types (list[ParameterType] | None) – Optional[list[enum.ParameterType]]

• search (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

app_names: list[StrictStr] | None

names: list[StrictStr] | None

data_types: list[enum.ParameterType] | None

search: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParametersUpdate(**kwargs)

AppVersionParametersUpdate object.

Parameters:

• source (KRN | None) – Optional[KRN]

• resource_parameters (list[AppVersionResourceParameters]) – list[type_1.AppVersionResourceParameters]

• kwargs (Any)

source: KRN | None

resource_parameters: list[type_1.AppVersionResourceParameters]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParametersDefaultsUpdate(**kwargs)

AppVersionParametersDefaultsUpdate object.

Parameters:

• parameters (list[ParameterItemNoComment] | None) – Optional[list[type_1.ParameterItemNoComment]]

• kwargs (Any)

parameters: list[type_1.ParameterItemNoComment] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppParameter(**kwargs)

AppParameter object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• parameters (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

app_name: StrictStr

parameters: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParametersUniqueValuesGet(**kwargs)

AppVersionParametersUniqueValuesGet object.

Parameters:

• app_parameters (list[AppParameter] | None) – Optional[list[AppParameter]]

• data_types (list[ParameterType] | None) – Optional[list[enum.ParameterType]]

• kwargs (Any)

app_parameters: list[AppParameter] | None

data_types: list[enum.ParameterType] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppVersionParametersFallbackValuesGet(**kwargs)

AppVersionParametersFallbackValuesGet object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParametersScheduleCreate(**kwargs)

ParametersScheduleCreate object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)])

• app_version (Annotated[str, Strict(strict=True)])

• scheduled_for (datetime)

• resources (Annotated[list[KRN], MinLen(min_length=1)])

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]])

• comment (Annotated[str, Strict(strict=True)] | None)

• revert (Revert | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParametersScheduleApply(**kwargs)

ParametersScheduleApply object.

Parameters:

• type (ParameterScheduleApplyType) – enum.ParameterScheduleApplyType

• source (KRN | None) – Optional[KRN]

• kwargs (Any)

type: enum.ParameterScheduleApplyType

source: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.App(**kwargs)

App object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParametersScheduleList(**kwargs)

ParametersScheduleList object.

Parameters:

• apps (list[App] | None) – Optional[list[App]]

• states (list[ParameterScheduleState] | None) – Optional[list[enum.ParameterScheduleState]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• parameter_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

apps: list[App] | None

states: list[enum.ParameterScheduleState] | None

resources: list[KRN] | None

parameter_names: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadCreate(**kwargs)

WorkloadCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• app_version (Annotated[str, Strict(strict=True)]) – StrictStr

• cluster_name (Annotated[str, Strict(strict=True)]) – StrictStr

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• runtime (Runtime | None) – Optional[Runtime]

• system (System | None) – Optional[manifest.System]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• kwargs (Any)

name: StrictStr

title: StrictStr | None

app_name: StrictStr

app_version: StrictStr

cluster_name: StrictStr

node_name: StrictStr | None

runtime: Runtime | None

system: manifest.System | None

deployment_type: enum.DeploymentType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadUpdate(**kwargs)

WorkloadUpdate object.

Parameters:

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• runtime (AppDeploymentRuntime | None) – Optional[type_1.AppDeploymentRuntime]

• system (System | None) – Optional[manifest.System]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• kwargs (Any)

app_version: StrictStr | None

cluster_name: StrictStr | None

node_name: StrictStr | None

title: StrictStr | None

runtime: type_1.AppDeploymentRuntime | None

system: manifest.System | None

deployment_type: enum.DeploymentType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadsApply(**kwargs)

WorkloadsApply object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadsStart(**kwargs)

WorkloadsStart object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadsStop(**kwargs)

WorkloadsStop object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadsDelete(**kwargs)

WorkloadsDelete object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadResourcesAdd(**kwargs)

WorkloadResourcesAdd object.

Parameters:

• resources (list[Resource] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadResourcesRemove(**kwargs)

WorkloadResourcesRemove object.

Parameters:

• resources (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

resources: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.WorkloadsBulkUpdate(**kwargs)

WorkloadsBulkUpdate object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• runtime (AppDeploymentRuntime | None) – Optional[type_1.AppDeploymentRuntime]

• system (System | None) – Optional[manifest.System]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• kwargs (Any)

workload_names: list[StrictStr] | None

app_name: StrictStr | None

app_version: StrictStr | None

runtime: type_1.AppDeploymentRuntime | None

system: manifest.System | None

deployment_type: enum.DeploymentType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppExtraField(**kwargs)

AppExtraField object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_versions (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

app_name: StrictStr | None

app_versions: list[StrictStr] | None

name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetInsightsFilter(**kwargs)

AssetInsightsFilter object.

Parameters:

• operator (AssetInsightsOperator | None) – Optional[enum.AssetInsightsOperator]

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• kwargs (Any)

operator: enum.AssetInsightsOperator | None

value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetPropertyExtraField(**kwargs)

AssetPropertyExtraField object.

Parameters:

• filters (list[AssetInsightsFilter] | None) – Optional[list[AssetInsightsFilter]]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• primitive_type (PropertyType | None) – Optional[enum.PropertyType]

• property_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

filters: list[AssetInsightsFilter] | None

name: StrictStr | None

primitive_type: enum.PropertyType | None

property_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Datastream(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.ControlChangeExtraField(**kwargs)

ControlChangeExtraField object.

Parameters:

• datastreams (list[Datastream] | None) – Optional[list[Datastream]]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• since (datetime | None) – Optional[datetime]

• statuses (list[ControlChangeState] | None) – Optional[list[enum.ControlChangeState]]

• kwargs (Any)

datastreams: list[Datastream] | None

name: StrictStr | None

since: datetime | None

statuses: list[enum.ControlChangeState] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CustomActionExtraField(**kwargs)

CustomActionExtraField object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• since (datetime | None) – Optional[datetime]

• statuses (list[CustomActionState] | None) – Optional[list[enum.CustomActionState]]

• kwargs (Any)

name: StrictStr | None

type: StrictStr | None

since: datetime | None

statuses: list[enum.CustomActionState] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DatastreamExtraFieldComputation(**kwargs)

DatastreamExtraFieldComputation object.

Parameters:

• agg (AssetInsightsAgg | None) – Optional[enum.AssetInsightsAgg]

• end_time (datetime | None) – Optional[datetime]

• start_time (datetime | None) – Optional[datetime]

• kwargs (Any)

agg: enum.AssetInsightsAgg | None

end_time: datetime | None

start_time: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DatastreamExtraField(**kwargs)

DatastreamExtraField object.

Parameters:

• computation (DatastreamExtraFieldComputation | None) – Optional[DatastreamExtraFieldComputation]

• datastream_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• filters (list[AssetInsightsFilter] | None) – Optional[list[AssetInsightsFilter]]

• kwargs (Any)

computation: DatastreamExtraFieldComputation | None

datastream_name: StrictStr | None

name: StrictStr | None

filters: list[AssetInsightsFilter] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityExtraField(**kwargs)

DataQualityExtraField object.

Parameters:

• computation (DatastreamExtraFieldComputation | None) – Optional[DatastreamExtraFieldComputation]

• data_quality_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

computation: DatastreamExtraFieldComputation | None

data_quality_name: StrictStr | None

name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParameterExtraField(**kwargs)

ParameterExtraField object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• filters (list[AssetInsightsFilter] | None) – Optional[list[AssetInsightsFilter]]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• parameter_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• primitive_type (ParameterType | None) – Optional[enum.ParameterType]

• kwargs (Any)

app_name: StrictStr | None

filters: list[AssetInsightsFilter] | None

name: StrictStr | None

parameter_name: StrictStr | None

primitive_type: enum.ParameterType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Type(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.RecommendationExtraField(**kwargs)

RecommendationExtraField object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• since (datetime | None) – Optional[datetime]

• source (KRN | None) – Optional[KRN]

• states (list[RecommendationState] | None) – Optional[list[enum.RecommendationState]]

• types (list[Type] | None) – Optional[list[Type]]

• kwargs (Any)

name: StrictStr | None

since: datetime | None

source: KRN | None

states: list[enum.RecommendationState] | None

types: list[Type] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParametersScheduleExtraField(**kwargs)

ParametersScheduleExtraField object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• schedule_type (AssetInsightsParameterScheduleType | None) – Optional[enum.AssetInsightsParameterScheduleType]

• max_date (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

schedule_type: enum.AssetInsightsParameterScheduleType | None

max_date: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetInsightsExtraFields(**kwargs)

AssetInsightsExtraFields object.

Parameters:

• apps (list[AppExtraField] | None) – Optional[list[AppExtraField]]

• asset_properties (list[AssetPropertyExtraField] | None) – Optional[list[AssetPropertyExtraField]]

• control_changes (list[ControlChangeExtraField] | None) – Optional[list[ControlChangeExtraField]]

• custom_actions (list[CustomActionExtraField] | None) – Optional[list[CustomActionExtraField]]

• datastreams (list[DatastreamExtraField] | None) – Optional[list[DatastreamExtraField]]

• data_qualities (list[DataQualityExtraField] | None) – Optional[list[DataQualityExtraField]]

• parameters (list[ParameterExtraField] | None) – Optional[list[ParameterExtraField]]

• recommendations (list[RecommendationExtraField] | None) – Optional[list[RecommendationExtraField]]

• parameters_schedule (list[ParametersScheduleExtraField] | None) – Optional[list[ParametersScheduleExtraField]]

• kwargs (Any)

apps: list[AppExtraField] | None

asset_properties: list[AssetPropertyExtraField] | None

control_changes: list[ControlChangeExtraField] | None

custom_actions: list[CustomActionExtraField] | None

datastreams: list[DatastreamExtraField] | None

data_qualities: list[DataQualityExtraField] | None

parameters: list[ParameterExtraField] | None

recommendations: list[RecommendationExtraField] | None

parameters_schedule: list[ParametersScheduleExtraField] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ControlChangeFilter(**kwargs)

ControlChangeFilter object.

Parameters:

• field (ControlChangeFilterField | None) – Optional[enum.ControlChangeFilterField]

• value (Annotated[str, Strict(strict=True)] | list[Annotated[str, Strict(strict=True)]] | None) – Optional[Union[StrictStr, list[StrictStr]]]

• kwargs (Any)

field: enum.ControlChangeFilterField | None

value: StrictStr | list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationFilter(**kwargs)

RecommendationFilter object.

Parameters:

• field (RecommendationFilterField | None) – Optional[enum.RecommendationFilterField]

• value (Annotated[str, Strict(strict=True)] | list[Annotated[str, Strict(strict=True)]] | None) – Optional[Union[StrictStr, list[StrictStr]]]

• kwargs (Any)

field: enum.RecommendationFilterField | None

value: StrictStr | list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataTagFilter(**kwargs)

DataTagFilter object.

Parameters:

• field (DataTagFilterField | None) – Optional[enum.DataTagFilterField]

• value (Annotated[str, Strict(strict=True)] | list[Annotated[str, Strict(strict=True)]] | None) – Optional[Union[StrictStr, list[StrictStr]]]

• kwargs (Any)

field: enum.DataTagFilterField | None

value: StrictStr | list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ControlChanges(**kwargs)

ControlChanges object.

Parameters:

• contains (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• filters (list[ControlChangeFilter] | None) – Optional[list[ControlChangeFilter]]

• kwargs (Any)

contains: StrictBool | None

filters: list[ControlChangeFilter] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Recommendations(**kwargs)

Recommendations object.

Parameters:

• contains (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• filters (list[RecommendationFilter] | None) – Optional[list[RecommendationFilter]]

• kwargs (Any)

contains: StrictBool | None

filters: list[RecommendationFilter] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataTags(**kwargs)

DataTags object.

Parameters:

• contains (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• filters (list[DataTagFilter] | None) – Optional[list[DataTagFilter]]

• kwargs (Any)

contains: StrictBool | None

filters: list[DataTagFilter] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetInsightsFilters(**kwargs)

AssetInsightsFilters object.

Parameters:

• control_changes (ControlChanges | None) – Optional[ControlChanges]

• recommendations (Recommendations | None) – Optional[Recommendations]

• data_tags (DataTags | None) – Optional[DataTags]

• kwargs (Any)

control_changes: ControlChanges | None

recommendations: Recommendations | None

data_tags: DataTags | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetInsightsSortBy(**kwargs)

AssetInsightsSortBy object.

Parameters:

• direction (AssetInsightsSortByDirection | None) – Optional[enum.AssetInsightsSortByDirection]

• field (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• sort_by_extra_field (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

direction: enum.AssetInsightsSortByDirection | None

field: StrictStr | None

sort_by_extra_field: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.AssetType(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.PinnedAsset(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.SearchItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.AssetInsightsGet(**kwargs)

AssetInsightsGet object.

Parameters:

• asset_names (list[AssetName] | None) – Optional[list[AssetName]]

• asset_states (list[AssetState] | None) – Optional[list[enum.AssetState]]

• asset_types (list[AssetType] | None) – Optional[list[AssetType]]

• extra_fields (AssetInsightsExtraFields | None) – Optional[AssetInsightsExtraFields]

• filters (AssetInsightsFilters | None) – Optional[AssetInsightsFilters]

• filter_assets_with_data_qualities (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• force_parameters_refresh (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• pinned_assets (list[PinnedAsset] | None) – Optional[list[PinnedAsset]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• sort_by (list[AssetInsightsSortBy] | None) – Optional[list[AssetInsightsSortBy]]

• kwargs (Any)

asset_names: list[AssetName] | None

asset_states: list[enum.AssetState] | None

asset_types: list[AssetType] | None

extra_fields: AssetInsightsExtraFields | None

filters: AssetInsightsFilters | None

filter_assets_with_data_qualities: StrictBool | None

force_parameters_refresh: StrictBool | None

pinned_assets: list[PinnedAsset] | None

search: list[SearchItem] | None

sort_by: list[AssetInsightsSortBy] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetPropertyCreate(**kwargs)

AssetPropertyCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]

• kwargs (Any)

name: StrictStr

title: StrictStr | None

value: StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetCreate(**kwargs)

AssetCreate object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)]) – StrictStr

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• properties (list[AssetPropertyCreate] | None) – Optional[list[AssetPropertyCreate]]

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

asset_type_name: StrictStr

name: StrictStr

properties: list[AssetPropertyCreate] | None

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetBulkCreate(**kwargs)

AssetBulkCreate object.

Parameters:

• assets (Annotated[list[AssetCreate], MinLen(min_length=1)]) – list[AssetCreate]

• kwargs (Any)

assets: list[AssetCreate]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Name(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.AssetsAdvancedList(**kwargs)

AssetsAdvancedList object.

Parameters:

• asset_type_name (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• names (list[Name] | None) – Optional[list[Name]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• status_state (list[AssetState] | None) – Optional[list[enum.AssetState]]

• kwargs (Any)

asset_type_name: list[StrictStr] | None

names: list[Name] | None

search: list[SearchItem] | None

status_state: list[enum.AssetState] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetTypeCreate(**kwargs)

AssetTypeCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

name: StrictStr

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetTypesAdvancedList(**kwargs)

AssetTypesAdvancedList object.

Parameters:

• names (list[Name] | None) – Optional[list[Name]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• kwargs (Any)

names: list[Name] | None

search: list[SearchItem] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.NameModel(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.AssetTypeBulkDelete(**kwargs)

AssetTypeBulkDelete object.

Parameters:

• names (Annotated[list[NameModel], MinLen(min_length=1)]) – list[NameModel]

• kwargs (Any)

names: list[NameModel]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetTypeUpdate(**kwargs)

AssetTypeUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.NameModel1(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.AssetBulkDelete(**kwargs)

AssetBulkDelete object.

Parameters:

• names (Annotated[list[NameModel1], MinLen(min_length=1)]) – list[NameModel1]

• kwargs (Any)

names: list[NameModel1]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AssetUpdate(**kwargs)

AssetUpdate object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• properties (list[AssetPropertyCreate] | None) – Optional[list[AssetPropertyCreate]]

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

asset_type_name: StrictStr | None

properties: list[AssetPropertyCreate] | None

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Resource(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.Source(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.ControlChangeClusteringGet(**kwargs)

ControlChangeClusteringGet object.

Parameters:

• end_date (datetime) – datetime

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• start_date (datetime) – datetime

• states (list[ControlChangeState] | None) – Optional[list[enum.ControlChangeState]]

• time_bucket (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

end_date: datetime

resources: list[KRN] | None

sources: list[KRN] | None

start_date: datetime

states: list[enum.ControlChangeState] | None

time_bucket: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ControlChangeCreate(**kwargs)

ControlChangeCreate object.

Parameters:

• expiration_date (datetime) – datetime

• from – Optional[type_1.ControlChangeFrom]

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN) – KRN

• retries (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• timeout (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• from_ (ControlChangeFrom | None)

• kwargs (Any)

expiration_date: datetime

from_: type_1.ControlChangeFrom | None

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

trace_id: StrictStr | None

resource: KRN

retries: StrictInt | None

timeout: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TraceId(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.ControlChangeLastGet(**kwargs)

ControlChangeLastGet object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• states (list[ControlChangeState] | None) – Optional[list[enum.ControlChangeState]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• kwargs (Any)

resources: list[KRN] | None

sources: list[KRN] | None

states: list[enum.ControlChangeState] | None

trace_ids: list[TraceId] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ControlChangesList(**kwargs)

ControlChangesList object.

Parameters:

• ids (list[UUID] | None) – Optional[list[UUID]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• states (list[ControlChangeState] | None) – Optional[list[enum.ControlChangeState]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• kwargs (Any)

ids: list[UUID] | None

resources: list[KRN] | None

sources: list[KRN] | None

states: list[enum.ControlChangeState] | None

trace_ids: list[TraceId] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ControlChangeRangeGet(**kwargs)

ControlChangeRangeGet object.

Parameters:

• end_date (datetime) – datetime

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• start_date (datetime) – datetime

• states (list[ControlChangeState] | None) – Optional[list[enum.ControlChangeState]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• kwargs (Any)

end_date: datetime

resources: list[KRN] | None

sources: list[KRN] | None

start_date: datetime

states: list[enum.ControlChangeState] | None

trace_ids: list[TraceId] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CustomActionCreate(**kwargs)

CustomActionCreate object.

Parameters:

• id (UUID | None) – Optional[UUID]

• timestamp (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

id: UUID | None

timestamp: datetime | None

created_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CreatedByItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.CustomActionsList(**kwargs)

CustomActionsList object.

Parameters:

• ids (list[UUID] | None) – Optional[list[UUID]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• created_by (list[KRN] | None) – Optional[list[KRN]]

• states (list[CustomActionState] | None) – Optional[list[enum.CustomActionState]]

• types (list[Type] | None) – Optional[list[Type]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• kwargs (Any)

ids: list[UUID] | None

resources: list[KRN] | None

created_by: list[KRN] | None

states: list[enum.CustomActionState] | None

types: list[Type] | None

trace_ids: list[TraceId] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CustomActionUpdate(**kwargs)

CustomActionUpdate object.

Parameters:

• status_logs (list[StatusLog] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CustomActionsTypeCreate(**kwargs)

CustomActionsTypeCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

name: StrictStr

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.CustomActionsTypeUpdate(**kwargs)

CustomActionsTypeUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityCreate(**kwargs)

DataQualityCreate object.

Parameters:

• resource (KRN)

• configurations (DataQualityConfigurations)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityUpdate(**kwargs)

DataQualityUpdate object.

Parameters:

• configurations (DataQualityConfigurations | None) – Optional[type_1.DataQualityConfigurations]

• kwargs (Any)

configurations: type_1.DataQualityConfigurations | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityList(**kwargs)

DataQualityList object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkDataQualityUpsert(**kwargs)

BulkDataQualityUpsert object.

Parameters:

• data_qualities (list[DataQualityCreationFields] | None) – Optional[list[type_1.DataQualityCreationFields]]

• kwargs (Any)

data_qualities: list[type_1.DataQualityCreationFields] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkDataQualityDelete(**kwargs)

BulkDataQualityDelete object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityMetricCreate(**kwargs)

DataQualityMetricCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• data_type_name (DataType) – enum.DataType

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

title: StrictStr

data_type_name: enum.DataType

description: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityMetricUpdate(**kwargs)

DataQualityMetricUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityMetricsList(**kwargs)

DataQualityMetricsList object.

Parameters:

• names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• data_type_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• search (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

names: list[StrictStr] | None

data_type_names: list[StrictStr] | None

search: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityMetric(**kwargs)

DataQualityMetric object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type_name (DataType | None) – Optional[enum.DataType]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

title: StrictStr | None

data_type_name: enum.DataType | None

description: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.UpsertDataQualityMetricsBulk(**kwargs)

UpsertDataQualityMetricsBulk object.

Parameters:

• data_quality_metrics (list[DataQualityMetric] | None) – Optional[list[DataQualityMetric]]

• kwargs (Any)

data_quality_metrics: list[DataQualityMetric] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DeleteDataQualityMetricsBulk(**kwargs)

DeleteDataQualityMetricsBulk object.

Parameters:

• metric_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

metric_names: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Configurations(**kwargs)

Configurations object.

Parameters:

• kelvin_stale_detection (KelvinStaleDetection | None) – Optional[type_1.KelvinStaleDetection]

• kelvin_out_of_range_detection (KelvinOutOfRangeDetection | None) – Optional[type_1.KelvinOutOfRangeDetection]

• kelvin_outlier_detection (KelvinOutlierDetection | None) – Optional[type_1.KelvinOutlierDetection]

• kelvin_data_availability (KelvinDataAvailability | None) – Optional[type_1.KelvinDataAvailability]

• kwargs (Any)

kelvin_stale_detection: type_1.KelvinStaleDetection | None

kelvin_out_of_range_detection: type_1.KelvinOutOfRangeDetection | None

kelvin_outlier_detection: type_1.KelvinOutlierDetection | None

kelvin_data_availability: type_1.KelvinDataAvailability | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualitySimulate(**kwargs)

DataQualitySimulate object.

Parameters:

• resource (KRN | None) – Optional[KRN]

• configurations (Configurations | None) – Optional[Configurations]

• start_time (datetime | None) – Optional[datetime]

• end_time (datetime | None) – Optional[datetime]

• kwargs (Any)

resource: KRN | None

configurations: Configurations | None

start_time: datetime | None

end_time: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataQualityStatistics(**kwargs)

DataQualityStatistics object.

Parameters:

• asset_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• asset_type_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• start_time (datetime) – datetime

• end_time (datetime) – datetime

• threshold (Annotated[float, Strict(strict=True)]) – StrictFloat

• kwargs (Any)

asset_names: list[StrictStr] | None

asset_type_names: list[StrictStr] | None

start_time: datetime

end_time: datetime

threshold: StrictFloat

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamSemanticTypeCreate(**kwargs)

DataStreamSemanticTypeCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

name: StrictStr

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamSemanticTypeUpdate(**kwargs)

DataStreamSemanticTypeUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamUnitCreate(**kwargs)

DataStreamUnitCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• symbol (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

name: StrictStr

symbol: StrictStr

title: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkDataStreamUnitCreate(**kwargs)

BulkDataStreamUnitCreate object.

Parameters:

• units (Annotated[list[DataStreamUnitCreate], MinLen(min_length=1)]) – list[DataStreamUnitCreate]

• kwargs (Any)

units: list[DataStreamUnitCreate]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamUnitUpdate(**kwargs)

DataStreamUnitUpdate object.

Parameters:

• symbol (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

symbol: StrictStr | None

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamCreate(**kwargs)

DataStreamCreate object.

Parameters:

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• data_type_name (DataType) – enum.DataType

• semantic_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• type (DataStreamType) – enum.DataStreamType

• unit_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

description: StrictStr | None

name: StrictStr

data_type_name: enum.DataType

semantic_type_name: StrictStr | None

title: StrictStr

type: enum.DataStreamType

unit_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkDataStreamCreate(**kwargs)

BulkDataStreamCreate object.

Parameters:

• datastreams (Annotated[list[DataStreamCreate], MinLen(min_length=1)]) – list[DataStreamCreate]

• kwargs (Any)

datastreams: list[DataStreamCreate]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataStreamUpdate(**kwargs)

DataStreamUpdate object.

Parameters:

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (DataStreamType | None) – Optional[enum.DataStreamType]

• semantic_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• unit_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

description: StrictStr | None

title: StrictStr | None

type: enum.DataStreamType | None

semantic_type_name: StrictStr | None

unit_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataTypeName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.NameModel2(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.SemanticTypeName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.UnitName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.DataStreamsList(**kwargs)

DataStreamsList object.

Parameters:

• data_type_names (list[DataTypeName] | None) – Optional[list[DataTypeName]]

• names (list[NameModel2] | None) – Optional[list[NameModel2]]

• types (list[DataStreamType] | None) – Optional[list[enum.DataStreamType]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• semantic_type_names (list[SemanticTypeName] | None) – Optional[list[SemanticTypeName]]

• unit_names (list[UnitName] | None) – Optional[list[UnitName]]

• kwargs (Any)

data_type_names: list[DataTypeName] | None

names: list[NameModel2] | None

types: list[enum.DataStreamType] | None

search: list[SearchItem] | None

semantic_type_names: list[SemanticTypeName] | None

unit_names: list[UnitName] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DatastreamName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.BulkDataStreamDelete(**kwargs)

BulkDataStreamDelete object.

Parameters:

• datastream_names (Annotated[list[DatastreamName], MinLen(min_length=1)]) – list[DatastreamName]

• kwargs (Any)

datastream_names: list[DatastreamName]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DatastreamNameModel(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.DataStreamContextsList(**kwargs)

DataStreamContextsList object.

Parameters:

• datastream_names (list[DatastreamNameModel] | None) – Optional[list[DatastreamNameModel]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• writable (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

datastream_names: list[DatastreamNameModel] | None

resources: list[KRN] | None

sources: list[KRN] | None

writable: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Context(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.DataTagCreate(**kwargs)

DataTagCreate object.

Parameters:

• start_date (datetime) – datetime

• end_date (datetime) – datetime

• tag_name (Annotated[str, Strict(strict=True)]) – StrictStr

• resource (KRN) – KRN

• source (KRN | None) – Optional[KRN]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• contexts (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

start_date: datetime

end_date: datetime

tag_name: StrictStr

resource: KRN

source: KRN | None

description: StrictStr | None

contexts: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.DataTagUpdate(**kwargs)

DataTagUpdate object.

Parameters:

• start_date (datetime | None) – Optional[datetime]

• end_date (datetime | None) – Optional[datetime]

• tag_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• contexts (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

start_date: datetime | None

end_date: datetime | None

tag_name: StrictStr | None

resource: KRN | None

description: StrictStr | None

contexts: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TagName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.DataTagList(**kwargs)

DataTagList object.

Parameters:

• ids (list[UUID] | None) – Optional[list[UUID]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• tag_names (list[TagName] | None) – Optional[list[TagName]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• contexts (list[KRN] | None) – Optional[list[KRN]]

• start_date (datetime | None) – Optional[datetime]

• end_date (datetime | None) – Optional[datetime]

• kwargs (Any)

ids: list[UUID] | None

search: list[SearchItem] | None

tag_names: list[TagName] | None

resources: list[KRN] | None

sources: list[KRN] | None

contexts: list[KRN] | None

start_date: datetime | None

end_date: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TagCreate(**kwargs)

TagCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

name: StrictStr

metadata: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TagUpdate(**kwargs)

TagUpdate object.

Parameters:

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

metadata: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EventCreate(**kwargs)

EventCreate object.

Parameters:

• id (UUID | None) – Optional[UUID]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created_at (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• kwargs (Any)

id: UUID | None

trace_id: StrictStr | None

created_at: datetime | None

created_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EventUpdate(**kwargs)

EventUpdate object.

Parameters:

• state (EventState | None) – Optional[enum.EventState]

• kwargs (Any)

state: enum.EventState | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.FilesList(**kwargs)

FilesList object.

Parameters:

• file_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• sources (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• search (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

file_names: list[StrictStr] | None

sources: list[StrictStr] | None

search: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.GuardrailCreate(**kwargs)

GuardrailCreate object.

Parameters:

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumberConfig | None)

• updater (GuardrailUpdater | None)

• resource (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.GuardrailUpdate(**kwargs)

GuardrailUpdate object.

Parameters:

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumberConfig | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.GuardrailsList(**kwargs)

GuardrailsList object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• control_disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

resources: list[KRN] | None

control_disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkGuardrailsCreate(**kwargs)

BulkGuardrailsCreate object.

Parameters:

• guardrails (list[GuardrailConfigWithResource] | None) – Optional[list[type_1.GuardrailConfigWithResource]]

• kwargs (Any)

guardrails: list[type_1.GuardrailConfigWithResource] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BulkGuardrailsDelete(**kwargs)

BulkGuardrailsDelete object.

Parameters:

• resources (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resources: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingAutoUpdate(**kwargs)

ClusterSettingAutoUpdate object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

enabled: StrictBool | None

interval: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingDeployOptions(**kwargs)

ClusterSettingDeployOptions object.

Parameters:

• instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• pre_download (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

instantly_apply: StrictBool | None

pre_download: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingForwardLogs(**kwargs)

ClusterSettingForwardLogs object.

Parameters:

• buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

buffer_size: StrictInt | None

enabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingSync(**kwargs)

ClusterSettingSync object.

Parameters:

• interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

interval: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingTelemetry(**kwargs)

ClusterSettingTelemetry object.

Parameters:

• buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• node_alerts_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

buffer_size: StrictInt | None

enabled: StrictBool | None

node_alerts_enabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeUi(**kwargs)

EdgeUi object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeCcm(**kwargs)

EdgeCcm object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeK8s(**kwargs)

EdgeK8s object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeInfo(**kwargs)

EdgeInfo object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeMqtt(**kwargs)

EdgeMqtt object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• expose (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• anonymous (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

expose: StrictBool | None

anonymous: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeNats(**kwargs)

EdgeNats object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeSync(**kwargs)

EdgeSync object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeLeaderApi(**kwargs)

EdgeLeaderApi object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.EdgeCustomActionManager(**kwargs)

EdgeCustomActionManager object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSettingEdgeApps(**kwargs)

ClusterSettingEdgeApps object.

Parameters:

• edge_ui (EdgeUi | None) – Optional[EdgeUi]

• edge_ccm (EdgeCcm | None) – Optional[EdgeCcm]

• edge_k8s (EdgeK8s | None) – Optional[EdgeK8s]

• edge_info (EdgeInfo | None) – Optional[EdgeInfo]

• edge_mqtt (EdgeMqtt | None) – Optional[EdgeMqtt]

• edge_nats (EdgeNats | None) – Optional[EdgeNats]

• edge_sync (EdgeSync | None) – Optional[EdgeSync]

• edge_leader_api (EdgeLeaderApi | None) – Optional[EdgeLeaderApi]

• edge_custom_action_manager (EdgeCustomActionManager | None) – Optional[EdgeCustomActionManager]

• kwargs (Any)

edge_ui: EdgeUi | None

edge_ccm: EdgeCcm | None

edge_k8s: EdgeK8s | None

edge_info: EdgeInfo | None

edge_mqtt: EdgeMqtt | None

edge_nats: EdgeNats | None

edge_sync: EdgeSync | None

edge_leader_api: EdgeLeaderApi | None

edge_custom_action_manager: EdgeCustomActionManager | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterSetting(**kwargs)

ClusterSetting object.

Parameters:

• auto_update (ClusterSettingAutoUpdate | None) – Optional[ClusterSettingAutoUpdate]

• cluster_upgrade (ClusterSettingDeployOptions | None) – Optional[ClusterSettingDeployOptions]

• forward_logs (ClusterSettingForwardLogs | None) – Optional[ClusterSettingForwardLogs]

• sync (ClusterSettingSync | None) – Optional[ClusterSettingSync]

• telemetry (ClusterSettingTelemetry | None) – Optional[ClusterSettingTelemetry]

• workload_deploy (ClusterSettingDeployOptions | None) – Optional[ClusterSettingDeployOptions]

• edge_apps (ClusterSettingEdgeApps | None) – Optional[ClusterSettingEdgeApps]

• kwargs (Any)

auto_update: ClusterSettingAutoUpdate | None

cluster_upgrade: ClusterSettingDeployOptions | None

forward_logs: ClusterSettingForwardLogs | None

sync: ClusterSettingSync | None

telemetry: ClusterSettingTelemetry | None

workload_deploy: ClusterSettingDeployOptions | None

edge_apps: ClusterSettingEdgeApps | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.InstanceSettingsKelvinClusterUpdate(**kwargs)

InstanceSettingsKelvinClusterUpdate object.

Parameters:

• payload (ClusterSetting | None) – Optional[ClusterSetting]

• kwargs (Any)

payload: ClusterSetting | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.InstanceSettingsUpdate(**kwargs)

InstanceSettingsUpdate object.

Parameters:

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

payload: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.OrchestrationClustersCreate(**kwargs)

OrchestrationClustersCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (ClusterType | None) – Optional[enum.ClusterType]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

type: enum.ClusterType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterUpgrade(**kwargs)

ClusterUpgrade object.

Parameters:

• instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• pre_download (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

instantly_apply: StrictBool | None

pre_download: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterEdgeAPICredentials(**kwargs)

ClusterEdgeAPICredentials object.

Parameters:

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• password (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

username: StrictStr | None

password: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterEdgeApps(**kwargs)

ClusterEdgeApps object.

Parameters:

• edge_ui (EdgeUi | None) – Optional[EdgeUi]

• edge_ccm (EdgeCcm | None) – Optional[EdgeCcm]

• edge_k8s (EdgeK8s | None) – Optional[EdgeK8s]

• edge_info (EdgeInfo | None) – Optional[EdgeInfo]

• edge_mqtt (EdgeMqtt | None) – Optional[EdgeMqtt]

• edge_nats (EdgeNats | None) – Optional[EdgeNats]

• edge_sync (EdgeSync | None) – Optional[EdgeSync]

• edge_leader_api (EdgeLeaderApi | None) – Optional[EdgeLeaderApi]

• edge_custom_action_manager (EdgeCustomActionManager | None) – Optional[EdgeCustomActionManager]

• kwargs (Any)

edge_ui: EdgeUi | None

edge_ccm: EdgeCcm | None

edge_k8s: EdgeK8s | None

edge_info: EdgeInfo | None

edge_mqtt: EdgeMqtt | None

edge_nats: EdgeNats | None

edge_sync: EdgeSync | None

edge_leader_api: EdgeLeaderApi | None

edge_custom_action_manager: EdgeCustomActionManager | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ClusterEdgeOptions(**kwargs)

ClusterEdgeOptions object.

Parameters:

• image_pull_policy (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

image_pull_policy: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.OrchestrationClustersUpdate(**kwargs)

OrchestrationClustersUpdate object.

Parameters:

• forward_logs_buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• forward_logs_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• manifests_scrape_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• manifests_scrape_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• sync_scrape_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• telemetry_buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• telemetry_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• telemetry_alerts_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• upgrade (ClusterUpgrade | None) – Optional[ClusterUpgrade]

• api_credentials (ClusterEdgeAPICredentials | None) – Optional[ClusterEdgeAPICredentials]

• edge_apps (ClusterEdgeApps | None) – Optional[ClusterEdgeApps]

• edge_options (ClusterEdgeOptions | None) – Optional[ClusterEdgeOptions]

• kwargs (Any)

forward_logs_buffer_size: StrictInt | None

forward_logs_enabled: StrictBool | None

manifests_scrape_enabled: StrictBool | None

manifests_scrape_interval: StrictInt | None

ready: StrictBool | None

sync_scrape_interval: StrictInt | None

telemetry_buffer_size: StrictInt | None

telemetry_enabled: StrictBool | None

telemetry_alerts_enabled: StrictBool | None

title: StrictStr | None

upgrade: ClusterUpgrade | None

api_credentials: ClusterEdgeAPICredentials | None

edge_apps: ClusterEdgeApps | None

edge_options: ClusterEdgeOptions | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.PropertyCreate(**kwargs)

PropertyCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• primitive_type (PropertyType) – enum.PropertyType

• kwargs (Any)

name: StrictStr

title: StrictStr

primitive_type: enum.PropertyType

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.PropertyUniqueValuesGet(**kwargs)

PropertyUniqueValuesGet object.

Parameters:

• property_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• resource_types (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• primitive_types (list[PropertyType] | None) – Optional[list[enum.PropertyType]]

• kwargs (Any)

property_names: list[StrictStr] | None

resource_types: list[StrictStr] | None

primitive_types: list[enum.PropertyType] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.PropertyValuesUpdate(**kwargs)

PropertyValuesUpdate object.

Parameters:

• resource_values (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]

• kwargs (Any)

resource_values: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.PropertyValuesDelete(**kwargs)

PropertyValuesDelete object.

Parameters:

• resources (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

resources: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RangeGetPropertyValues(**kwargs)

RangeGetPropertyValues object.

Parameters:

• resources (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• start_date (datetime) – datetime

• end_date (datetime) – datetime

• kwargs (Any)

resources: list[StrictStr] | None

start_date: datetime

end_date: datetime

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ResourceName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.RecommendationClusteringGet(**kwargs)

RecommendationClusteringGet object.

Parameters:

• end_date (datetime) – datetime

• resource_names (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• start_date (datetime) – datetime

• states (list[RecommendationState] | None) – Optional[list[enum.RecommendationState]]

• time_bucket (Annotated[str, Strict(strict=True)]) – StrictStr

• types (list[Type] | None) – Optional[list[Type]]

• kwargs (Any)

end_date: datetime

resource_names: list[KRN] | None

sources: list[KRN] | None

trace_ids: list[TraceId] | None

start_date: datetime

states: list[enum.RecommendationState] | None

time_bucket: StrictStr

types: list[Type] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationCreate(**kwargs)

RecommendationCreate object.

Parameters:

• id (UUID | None) – Optional[UUID]

• actions (RecommendationActionsCreate | None) – Optional[type_1.RecommendationActionsCreate]

• state (RecommendationStateCreate | None) – Optional[enum.RecommendationStateCreate]

• source (KRN | None) – Optional[KRN]

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• kwargs (Any)

id: UUID | None

actions: type_1.RecommendationActionsCreate | None

state: enum.RecommendationStateCreate | None

source: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationLastGet(**kwargs)

RecommendationLastGet object.

Parameters:

• resources (list[KRN]) – list[KRN]

• sources (list[KRN] | None) – Optional[list[KRN]]

• states (list[RecommendationState] | None) – Optional[list[enum.RecommendationState]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• types (list[Type] | None) – Optional[list[Type]]

• kwargs (Any)

resources: list[KRN]

sources: list[KRN] | None

states: list[enum.RecommendationState] | None

trace_ids: list[TraceId] | None

types: list[Type] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationsList(**kwargs)

RecommendationsList object.

Parameters:

• ids (list[UUID] | None) – Optional[list[UUID]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• sources (list[KRN] | None) – Optional[list[KRN]]

• states (list[RecommendationState] | None) – Optional[list[enum.RecommendationState]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• types (list[Type] | None) – Optional[list[Type]]

• kwargs (Any)

ids: list[UUID] | None

resources: list[KRN] | None

sources: list[KRN] | None

states: list[enum.RecommendationState] | None

trace_ids: list[TraceId] | None

types: list[Type] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationRangeGet(**kwargs)

RecommendationRangeGet object.

Parameters:

• end_date (datetime) – datetime

• resources (list[KRN]) – list[KRN]

• sources (list[KRN] | None) – Optional[list[KRN]]

• trace_ids (list[TraceId] | None) – Optional[list[TraceId]]

• start_date (datetime) – datetime

• states (list[RecommendationState] | None) – Optional[list[enum.RecommendationState]]

• types (list[Type] | None) – Optional[list[Type]]

• kwargs (Any)

end_date: datetime

resources: list[KRN]

sources: list[KRN] | None

trace_ids: list[TraceId] | None

start_date: datetime

states: list[enum.RecommendationState] | None

types: list[Type] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationTypeCreate(**kwargs)

RecommendationTypeCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

name: StrictStr

title: StrictStr

metadata: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationTypeUpdate(**kwargs)

RecommendationTypeUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

title: StrictStr | None

metadata: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationAcceptUpdate(**kwargs)

RecommendationAcceptUpdate object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

confidence: StrictInt | None

message: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RecommendationRejectUpdate(**kwargs)

RecommendationRejectUpdate object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

confidence: StrictInt | None

message: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.SecretCreate(**kwargs)

SecretCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• value (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

name: StrictStr

value: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.SecretUpdate(**kwargs)

SecretUpdate object.

Parameters:

• value (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

value: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ThreadCreate(**kwargs)

ThreadCreate object.

Parameters:

• body (Annotated[str, Strict(strict=True)]) – StrictStr

• file (bytes | None) – Optional[bytes]

• kwargs (Any)

body: StrictStr

file: bytes | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ThreadReplyCreate(**kwargs)

ThreadReplyCreate object.

Parameters:

• body (Annotated[str, Strict(strict=True)]) – StrictStr

• file (bytes | None) – Optional[bytes]

• kwargs (Any)

body: StrictStr

file: bytes | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ThreadReplyUpdate(**kwargs)

ThreadReplyUpdate object.

Parameters:

• body (Annotated[str, Strict(strict=True)]) – StrictStr

• file (bytes | None) – Optional[bytes]

• kwargs (Any)

body: StrictStr

file: bytes | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ThreadUpdate(**kwargs)

ThreadUpdate object.

Parameters:

• body (Annotated[str, Strict(strict=True)]) – StrictStr

• file (bytes | None) – Optional[bytes]

• kwargs (Any)

body: StrictStr

file: bytes | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TimeseriesCreate(**kwargs)

TimeseriesCreate object.

Parameters:

• data (list[KelvinMessage]) – list[type_1.KelvinMessage]

• kwargs (Any)

data: list[type_1.KelvinMessage]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Selector(**kwargs)

Selector object.

Parameters:

• fields (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• resource (KRN) – KRN

• kwargs (Any)

fields: list[StrictStr] | None

resource: KRN

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TimeseriesLastGet(**kwargs)

TimeseriesLastGet object.

Parameters:

• selectors (list[Selector] | None) – Optional[list[Selector]]

• kwargs (Any)

selectors: list[Selector] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ResourceItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.SourceItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.TimeseriesList(**kwargs)

TimeseriesList object.

Parameters:

• resource (list[KRN] | None) – Optional[list[KRN]]

• source (list[KRN] | None) – Optional[list[KRN]]

• kwargs (Any)

resource: list[KRN] | None

source: list[KRN] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TimeseriesRangeGet(**kwargs)

TimeseriesRangeGet object.

Parameters:

• agg (TimeseriesAgg | None) – Optional[enum.TimeseriesAgg]

• end_time (datetime) – datetime

• fill (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• group_by_selector (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• order (TimeseriesOrder | None) – Optional[enum.TimeseriesOrder]

• selectors (list[Selector]) – list[Selector]

• start_time (datetime) – datetime

• time_bucket (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• time_shift (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

agg: enum.TimeseriesAgg | None

end_time: datetime

fill: StrictStr | None

group_by_selector: StrictBool | None

order: enum.TimeseriesOrder | None

selectors: list[Selector]

start_time: datetime

time_bucket: StrictStr | None

time_shift: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TimeseriesRangeDownload(**kwargs)

TimeseriesRangeDownload object.

Parameters:

• agg (TimeseriesAgg | None)

• end_time (datetime)

• fill (Annotated[str, Strict(strict=True)] | None)

• group_by_selector (Annotated[bool, Strict(strict=True)] | None)

• order (TimeseriesOrder | None)

• selectors (list[Selector])

• start_time (datetime)

• time_bucket (Annotated[str, Strict(strict=True)] | None)

• time_shift (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.UserSettingsUpdate(**kwargs)

UserSettingsUpdate object.

Parameters:

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

payload: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.SharedSettingsUpdate(**kwargs)

SharedSettingsUpdate object.

Parameters:

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

payload: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TaskCreate(**kwargs)

TaskCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resources (list[TaskResourceListItem] | None) – Optional[list[TaskResourceListItem]]

• ui_metadata (TaskUIMetadata | None) – Optional[type_1.TaskUIMetadata]

• definition (TaskDefinition | None) – Optional[type_1.TaskDefinition]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

resources: list[TaskResourceListItem] | None

ui_metadata: type_1.TaskUIMetadata | None

definition: type_1.TaskDefinition | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TaskUpdate(**kwargs)

TaskUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resources (list[TaskResourceListItem] | None) – Optional[list[TaskResourceListItem]]

• ui_metadata (TaskUIMetadata | None) – Optional[type_1.TaskUIMetadata]

• definition (TaskDefinition | None) – Optional[type_1.TaskDefinition]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

resources: list[TaskResourceListItem] | None

ui_metadata: type_1.TaskUIMetadata | None

definition: type_1.TaskDefinition | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TaskResourcesAdd(**kwargs)

TaskResourcesAdd object.

Parameters:

kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.TaskResourcesRemove(**kwargs)

TaskResourcesRemove object.

Parameters:

kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RoleName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.GroupCreate(**kwargs)

GroupCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• role_names (list[RoleName] | None) – Optional[list[RoleName]]

• kwargs (Any)

name: StrictStr

title: StrictStr

description: StrictStr | None

role_names: list[RoleName] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.GroupUpdate(**kwargs)

GroupUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• role_names (list[RoleName] | None) – Optional[list[RoleName]]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

role_names: list[RoleName] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.GroupName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.RoleCreate(**kwargs)

RoleCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• group_names (list[GroupName] | None) – Optional[list[GroupName]]

• kwargs (Any)

name: StrictStr

title: StrictStr

description: StrictStr | None

group_names: list[GroupName] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RoleUpdate(**kwargs)

RoleUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• group_names (list[GroupName] | None) – Optional[list[GroupName]]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

group_names: list[GroupName] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.Rule(**kwargs)

Rule object.

Parameters:

• actions (list[RolePolicyAction]) – list[enum.RolePolicyAction]

• condition (RolePolicyCondition | None) – Optional[type_1.RolePolicyCondition]

• kwargs (Any)

actions: list[enum.RolePolicyAction]

condition: type_1.RolePolicyCondition | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RolePolicyCreate(**kwargs)

RolePolicyCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• resource_type (ResourceType) – enum.ResourceType

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• rule (Rule) – Rule

• kwargs (Any)

name: StrictStr

resource_type: enum.ResourceType

title: StrictStr

description: StrictStr | None

rule: Rule

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.RolePolicyUpdate(**kwargs)

RolePolicyUpdate object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• rule (Rule | None) – Optional[Rule]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

rule: Rule | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.LegacyAppCreate(**kwargs)

LegacyAppCreate object.

Parameters:

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

payload: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.LegacyAppUpdate(**kwargs)

LegacyAppUpdate object.

Parameters:

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

description: StrictStr | None

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.BridgeDeploy(**kwargs)

BridgeDeploy object.

Parameters:

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)]) – StrictStr

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• payload (AppYaml) – type_1.AppYaml

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

app_version: StrictStr | None

cluster_name: StrictStr

node_name: StrictStr | None

name: StrictStr

payload: type_1.AppYaml

title: StrictStr | None

app_name: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParametersAppVersionUpdate(**kwargs)

ParametersAppVersionUpdate object.

Parameters:

• source (KRN | None) – Optional[KRN]

• resource_parameters (list[ResourceParameters]) – list[type_1.ResourceParameters]

• kwargs (Any)

source: KRN | None

resource_parameters: list[type_1.ResourceParameters]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.AppName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.NameModel3(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.ParametersDefinitionsList(**kwargs)

ParametersDefinitionsList object.

Parameters:

• app_names (list[AppName] | None) – Optional[list[AppName]]

• names (list[NameModel3] | None) – Optional[list[NameModel3]]

• primitive_types (list[ParameterType] | None) – Optional[list[enum.ParameterType]]

• search (list[SearchItem] | None) – Optional[list[SearchItem]]

• kwargs (Any)

app_names: list[AppName] | None

names: list[NameModel3] | None

primitive_types: list[enum.ParameterType] | None

search: list[SearchItem] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParameterAppVersion(**kwargs)

ParameterAppVersion object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.requests.ParameterName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.requests.ResourceParametersList(**kwargs)

ResourceParametersList object.

Parameters:

• apps (list[ParameterAppVersion] | None) – Optional[list[ParameterAppVersion]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• parameter_names (list[ParameterName] | None) – Optional[list[ParameterName]]

• start_date (datetime | None) – Optional[datetime]

• end_date (datetime | None) – Optional[datetime]

• kwargs (Any)

apps: list[ParameterAppVersion] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

resources: list[KRN] | None

parameter_names: list[ParameterName] | None

start_date: datetime | None

end_date: datetime | None

class kelvin.api.client.model.requests.Parameter(root)

Parameters:

root (list[P])

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

root: StrictStr

class kelvin.api.client.model.requests.AppParameterModel(**kwargs)

AppParameterModel object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• parameters (list[Parameter] | None) – Optional[list[Parameter]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

app_name: StrictStr

parameters: list[Parameter] | None

class kelvin.api.client.model.requests.ParametersValuesGet(**kwargs)

ParametersValuesGet object.

Parameters:

• app_parameters (list[AppParameterModel] | None) – Optional[list[AppParameterModel]]

• primitive_types (list[ParameterType] | None) – Optional[list[enum.ParameterType]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

app_parameters: list[AppParameterModel] | None

primitive_types: list[enum.ParameterType] | None

class kelvin.api.client.model.requests.LegacyWorkloadDeploy(**kwargs)

LegacyWorkloadDeploy object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• staged (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• source (KRN | None) – Optional[KRN]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

acp_name: StrictStr | None

app_name: StrictStr

app_version: StrictStr | None

cluster_name: StrictStr | None

node_name: StrictStr | None

instantly_apply: StrictBool | None

name: StrictStr | None

payload: dict[str, Any] | None

staged: StrictBool | None

source: KRN | None

title: StrictStr | None

class kelvin.api.client.model.requests.LegacyWorkloadApply(**kwargs)

LegacyWorkloadApply object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

workload_names: list[StrictStr] | None

class kelvin.api.client.model.requests.LegacyWorkloadConfigurationUpdate(**kwargs)

LegacyWorkloadConfigurationUpdate object.

Parameters:

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

configuration: dict[str, Any] | None

Responses

class kelvin.api.client.model.responses.AppVersionCreate(**kwargs)

AppVersionCreate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionGet(**kwargs)

AppVersionGet object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionPatch(**kwargs)

AppVersionPatch object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionUpdate(**kwargs)

AppVersionUpdate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionDeploy(**kwargs)

AppVersionDeploy object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

workload_names: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppResourcesListPaginatedResponseCursor(**kwargs)

AppResourcesListPaginatedResponseCursor object.

Parameters:

• data (list[AppResource] | None) – Optional[list[type_1.AppResource]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppResource] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppResourcesListPaginatedResponseLimits(**kwargs)

AppResourcesListPaginatedResponseLimits object.

Parameters:

• data (list[AppResource] | None) – Optional[list[type_1.AppResource]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppResource] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppResourcesListPaginatedResponseStream(**kwargs)

AppResourcesListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• resource (KRN | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• workloads (list[AppResourceWorkload] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ResourceCount(**kwargs)

ResourceCount object.

Parameters:

• total (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• running (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

total: StrictInt | None

running: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Deployment(**kwargs)

Deployment object.

Parameters:

• status (AppStatus | None) – Optional[enum.AppStatus]

• resource_count (ResourceCount | None) – Optional[ResourceCount]

• kwargs (Any)

status: enum.AppStatus | None

resource_count: ResourceCount | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppGet(**kwargs)

AppGet object.

Parameters:

• deployment (Deployment | None) – Optional[Deployment]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• dashboard_uid (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• versions (list[AppVersionOnly] | None)

• kwargs (Any)

deployment: Deployment | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsListPaginatedResponseCursor(**kwargs)

AppsListPaginatedResponseCursor object.

Parameters:

• data (list[AppShort] | None) – Optional[list[type_1.AppShort]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppShort] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsListPaginatedResponseLimits(**kwargs)

AppsListPaginatedResponseLimits object.

Parameters:

• data (list[AppShort] | None) – Optional[list[type_1.AppShort]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppShort] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsListPaginatedResponseStream(**kwargs)

AppsListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• dashboard_uid (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• status (AppStatus | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppPatch(**kwargs)

AppPatch object.

Parameters:

• deployment (Deployment | None) – Optional[Deployment]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• dashboard_uid (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• versions (list[AppVersionOnly] | None)

• kwargs (Any)

deployment: Deployment | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsContextListPaginatedResponseCursor(**kwargs)

AppsContextListPaginatedResponseCursor object.

Parameters:

• data (list[AppsResourceContext] | None) – Optional[list[type_1.AppsResourceContext]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppsResourceContext] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsContextListPaginatedResponseLimits(**kwargs)

AppsContextListPaginatedResponseLimits object.

Parameters:

• data (list[AppsResourceContext] | None) – Optional[list[type_1.AppsResourceContext]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppsResourceContext] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppsContextListPaginatedResponseStream(**kwargs)

AppsContextListPaginatedResponseStream object.

Parameters:

• resource (KRN | None)

• source (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParameterValuesListPaginatedResponseCursor(**kwargs)

AppVersionParameterValuesListPaginatedResponseCursor object.

Parameters:

• data (list[AppVersionParameter] | None) – Optional[list[type_1.AppVersionParameter]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppVersionParameter] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParameterValuesListPaginatedResponseLimits(**kwargs)

AppVersionParameterValuesListPaginatedResponseLimits object.

Parameters:

• data (list[AppVersionParameter] | None) – Optional[list[type_1.AppVersionParameter]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppVersionParameter] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParameterValuesListPaginatedResponseStream(**kwargs)

AppVersionParameterValuesListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• comment (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParametersHistoryListPaginatedResponseCursor(**kwargs)

AppVersionParametersHistoryListPaginatedResponseCursor object.

Parameters:

• data (list[AppVersionParameter] | None) – Optional[list[type_1.AppVersionParameter]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppVersionParameter] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParametersHistoryListPaginatedResponseLimits(**kwargs)

AppVersionParametersHistoryListPaginatedResponseLimits object.

Parameters:

• data (list[AppVersionParameter] | None) – Optional[list[type_1.AppVersionParameter]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppVersionParameter] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParametersHistoryListPaginatedResponseStream(**kwargs)

AppVersionParametersHistoryListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• comment (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• invalidated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppParametersListPaginatedResponseCursor(**kwargs)

AppParametersListPaginatedResponseCursor object.

Parameters:

• data (list[AppParameter] | None) – Optional[list[type_1.AppParameter]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AppParameter] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppParametersListPaginatedResponseLimits(**kwargs)

AppParametersListPaginatedResponseLimits object.

Parameters:

• data (list[AppParameter] | None) – Optional[list[type_1.AppParameter]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AppParameter] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppParametersListPaginatedResponseStream(**kwargs)

AppParametersListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• data_type (ParameterType | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParametersUniqueValuesGet(**kwargs)

AppVersionParametersUniqueValuesGet object.

Parameters:

• app_parameter_values (dict[str, dict[str, list[Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]]]] | None) – Optional[dict[str, dict[str, list[Union[StrictInt, StrictFloat, StrictStr, StrictBool]]]]]

• kwargs (Any)

app_parameter_values: dict[str, dict[str, list[StrictInt | StrictFloat | StrictStr | StrictBool]]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AppVersionParametersFallbackValuesGet(**kwargs)

AppVersionParametersFallbackValuesGet object.

Parameters:

• resource_parameters (dict[str, dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool]]]]

• kwargs (Any)

resource_parameters: dict[str, dict[str, StrictInt | StrictFloat | StrictStr | StrictBool]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersScheduleCreate(**kwargs)

ParametersScheduleCreate object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)])

• app_version (Annotated[str, Strict(strict=True)])

• scheduled_for (datetime)

• resources (Annotated[list[KRN], MinLen(min_length=1)])

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]])

• comment (Annotated[str, Strict(strict=True)] | None)

• revert (Revert | None)

• id (UUID)

• state (ParameterScheduleState)

• original_resource_parameters (list[ParameterScheduleResourceParameter] | None)

• error_msg (Annotated[str, Strict(strict=True)] | None)

• created_at (datetime)

• created_by (KRN)

• applied_at (datetime | None)

• applied_by (KRN | None)

• reverted_at (datetime | None)

• reverted_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersScheduleGet(**kwargs)

ParametersScheduleGet object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)])

• app_version (Annotated[str, Strict(strict=True)])

• scheduled_for (datetime)

• resources (Annotated[list[KRN], MinLen(min_length=1)])

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]])

• comment (Annotated[str, Strict(strict=True)] | None)

• revert (Revert | None)

• id (UUID)

• state (ParameterScheduleState)

• original_resource_parameters (list[ParameterScheduleResourceParameter] | None)

• error_msg (Annotated[str, Strict(strict=True)] | None)

• created_at (datetime)

• created_by (KRN)

• applied_at (datetime | None)

• applied_by (KRN | None)

• reverted_at (datetime | None)

• reverted_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersScheduleListPaginatedResponseCursor(**kwargs)

ParametersScheduleListPaginatedResponseCursor object.

Parameters:

• data (list[ParametersScheduleGet] | None) – Optional[list[ParametersScheduleGet]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[ParametersScheduleGet] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersScheduleListPaginatedResponseLimits(**kwargs)

ParametersScheduleListPaginatedResponseLimits object.

Parameters:

• data (list[ParametersScheduleGet] | None) – Optional[list[ParametersScheduleGet]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[ParametersScheduleGet] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersScheduleListPaginatedResponseStream(**kwargs)

ParametersScheduleListPaginatedResponseStream object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)])

• app_version (Annotated[str, Strict(strict=True)])

• scheduled_for (datetime)

• resources (Annotated[list[KRN], MinLen(min_length=1)])

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]])

• comment (Annotated[str, Strict(strict=True)] | None)

• revert (Revert | None)

• id (UUID)

• state (ParameterScheduleState)

• original_resource_parameters (list[ParameterScheduleResourceParameter] | None)

• error_msg (Annotated[str, Strict(strict=True)] | None)

• created_at (datetime)

• created_by (KRN)

• applied_at (datetime | None)

• applied_by (KRN | None)

• reverted_at (datetime | None)

• reverted_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadCreate(**kwargs)

WorkloadCreate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• runtime (WorkloadRuntime | None)

• system (System | None)

• staged (WorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadGet(**kwargs)

WorkloadGet object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• runtime (WorkloadRuntime | None)

• system (System | None)

• staged (WorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadUpdate(**kwargs)

WorkloadUpdate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• runtime (WorkloadRuntime | None)

• system (System | None)

• staged (WorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadDownload(**kwargs)

WorkloadDownload object.

Parameters:

• url (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• expires_in (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

url: StrictStr | None

expires_in: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadsListPaginatedResponseCursor(**kwargs)

WorkloadsListPaginatedResponseCursor object.

Parameters:

• data (list[WorkloadSummary] | None) – Optional[list[type_1.WorkloadSummary]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.WorkloadSummary] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadsListPaginatedResponseLimits(**kwargs)

WorkloadsListPaginatedResponseLimits object.

Parameters:

• data (list[WorkloadSummary] | None) – Optional[list[type_1.WorkloadSummary]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.WorkloadSummary] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadsListPaginatedResponseStream(**kwargs)

WorkloadsListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• staged (WorkloadStagedSummary | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadLogsGet(**kwargs)

WorkloadLogsGet object.

Parameters:

• logs (dict[str, list[Annotated[str, Strict(strict=True)]]] | None) – Optional[dict[str, list[StrictStr]]]

• kwargs (Any)

logs: dict[str, list[StrictStr]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.WorkloadResourcesAdd(**kwargs)

WorkloadResourcesAdd object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• runtime (WorkloadRuntime | None)

• system (System | None)

• staged (WorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetInsightsItem(**kwargs)

AssetInsightsItem object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• asset_type_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• extra_fields (dict[str, Any] | None) – Optional[dict[str, Any]]

• last_seen (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• pinned (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• state (AssetInsightsState | None) – Optional[enum.AssetInsightsState]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

asset_type_name: StrictStr | None

asset_type_title: StrictStr | None

extra_fields: dict[str, Any] | None

last_seen: datetime | None

name: StrictStr | None

pinned: StrictBool | None

state: enum.AssetInsightsState | None

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetInsightsGetPaginated(**kwargs)

AssetInsightsGetPaginated object.

Parameters:

• data (list[AssetInsightsItem] | None) – Optional[list[AssetInsightsItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[AssetInsightsItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetCreate(**kwargs)

AssetCreate object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None)

• asset_type_title (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• properties (list[AssetProperty] | None)

• in_use_by (list[KRN] | None)

• status (AssetStatusItem | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsListPaginatedResponseCursor(**kwargs)

AssetsListPaginatedResponseCursor object.

Parameters:

• data (list[Asset] | None) – Optional[list[type_1.Asset]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Asset] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsListPaginatedResponseLimits(**kwargs)

AssetsListPaginatedResponseLimits object.

Parameters:

• data (list[Asset] | None) – Optional[list[type_1.Asset]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Asset] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsListPaginatedResponseStream(**kwargs)

AssetsListPaginatedResponseStream object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None)

• asset_type_title (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• properties (list[AssetProperty] | None)

• in_use_by (list[KRN] | None)

• status (AssetStatusItem | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsAdvancedListPaginatedResponseCursor(**kwargs)

AssetsAdvancedListPaginatedResponseCursor object.

Parameters:

• data (list[Asset] | None)

• pagination (PaginationCursor | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsAdvancedListPaginatedResponseLimits(**kwargs)

AssetsAdvancedListPaginatedResponseLimits object.

Parameters:

• data (list[Asset] | None)

• pagination (PaginationLimits | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetsAdvancedListPaginatedResponseStream(**kwargs)

AssetsAdvancedListPaginatedResponseStream object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None)

• asset_type_title (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• properties (list[AssetProperty] | None)

• in_use_by (list[KRN] | None)

• status (AssetStatusItem | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetStatusCountGet(**kwargs)

AssetStatusCountGet object.

Parameters:

• offline (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• online (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• total (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• unknown (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

offline: StrictInt | None

online: StrictInt | None

total: StrictInt | None

unknown: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetStatusCurrentGet(**kwargs)

AssetStatusCurrentGet object.

Parameters:

• data (list[SimpleAsset] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypeCreate(**kwargs)

AssetTypeCreate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesListPaginatedResponseCursor(**kwargs)

AssetTypesListPaginatedResponseCursor object.

Parameters:

• data (list[AssetType] | None) – Optional[list[type_1.AssetType]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.AssetType] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesListPaginatedResponseLimits(**kwargs)

AssetTypesListPaginatedResponseLimits object.

Parameters:

• data (list[AssetType] | None) – Optional[list[type_1.AssetType]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.AssetType] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesListPaginatedResponseStream(**kwargs)

AssetTypesListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesAdvancedListPaginatedResponseCursor(**kwargs)

AssetTypesAdvancedListPaginatedResponseCursor object.

Parameters:

• data (list[AssetType] | None)

• pagination (PaginationCursor | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesAdvancedListPaginatedResponseLimits(**kwargs)

AssetTypesAdvancedListPaginatedResponseLimits object.

Parameters:

• data (list[AssetType] | None)

• pagination (PaginationLimits | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypesAdvancedListPaginatedResponseStream(**kwargs)

AssetTypesAdvancedListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypeGet(**kwargs)

AssetTypeGet object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetTypeUpdate(**kwargs)

AssetTypeUpdate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetGet(**kwargs)

AssetGet object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None)

• asset_type_title (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• properties (list[AssetProperty] | None)

• in_use_by (list[KRN] | None)

• status (AssetStatusItem | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.AssetUpdate(**kwargs)

AssetUpdate object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None)

• asset_type_title (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• properties (list[AssetProperty] | None)

• in_use_by (list[KRN] | None)

• status (AssetStatusItem | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeClustering(**kwargs)

ControlChangeClustering object.

Parameters:

• control_change_ids (list[UUID] | None) – Optional[list[UUID]]

• count (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• time_bucket_start (datetime | None) – Optional[datetime]

• kwargs (Any)

control_change_ids: list[UUID] | None

count: StrictInt | None

time_bucket_start: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeCreate(**kwargs)

ControlChangeCreate object.

Parameters:

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• id (UUID) – UUID

• last_state (ControlChangeState | None) – Optional[enum.ControlChangeState]

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• timestamp (datetime | None) – Optional[datetime]

• trace_id (UUID) – UUID

• kwargs (Any)

created_by: StrictStr | None

created_type: StrictStr | None

id: UUID

last_state: enum.ControlChangeState | None

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

resource: KRN | None

source: KRN | None

timestamp: datetime | None

trace_id: UUID

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeGetStatus(**kwargs)

ControlChangeGetStatus object.

Parameters:

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• reported (ControlChangeReported | None) – Optional[type_1.ControlChangeReported]

• state (ControlChangeState) – enum.ControlChangeState

• timestamp (datetime | None) – Optional[datetime]

• kwargs (Any)

message: StrictStr | None

reported: type_1.ControlChangeReported | None

state: enum.ControlChangeState

timestamp: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeGet(**kwargs)

ControlChangeGet object.

Parameters:

• created (datetime | None) – Optional[datetime]

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• id (UUID) – UUID

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• last_message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• last_state (ControlChangeState | None) – Optional[enum.ControlChangeState]

• retries (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• timeout (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• expiration_date (datetime | None) – Optional[datetime]

• from – Optional[type_1.ControlChangeFrom]

• reported (ControlChangeReported | None) – Optional[type_1.ControlChangeReported]

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• resource (KRN) – KRN

• status_log (list[ControlChangeGetStatus] | None) – Optional[list[ControlChangeGetStatus]]

• timestamp (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• from_ (ControlChangeFrom | None)

• kwargs (Any)

created: datetime | None

created_by: StrictStr | None

created_type: StrictStr | None

id: UUID

trace_id: StrictStr | None

last_message: StrictStr | None

last_state: enum.ControlChangeState | None

retries: StrictInt | None

timeout: StrictInt | None

expiration_date: datetime | None

from_: type_1.ControlChangeFrom | None

reported: type_1.ControlChangeReported | None

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

resource: KRN

status_log: list[ControlChangeGetStatus] | None

timestamp: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeLastGetPaginatedResponseCursor(**kwargs)

ControlChangeLastGetPaginatedResponseCursor object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeLastGetPaginatedResponseLimits(**kwargs)

ControlChangeLastGetPaginatedResponseLimits object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeLastGetPaginatedResponseStream(**kwargs)

ControlChangeLastGetPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• created_type (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• last_message (Annotated[str, Strict(strict=True)] | None)

• last_state (ControlChangeState | None)

• retries (Annotated[int, Strict(strict=True)] | None)

• timeout (Annotated[int, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• from_ (ControlChangeFrom | None)

• reported (ControlChangeReported | None)

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• resource (KRN)

• status_log (list[ControlChangeGetStatus] | None)

• timestamp (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangesListPaginatedResponseCursor(**kwargs)

ControlChangesListPaginatedResponseCursor object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangesListPaginatedResponseLimits(**kwargs)

ControlChangesListPaginatedResponseLimits object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangesListPaginatedResponseStream(**kwargs)

ControlChangesListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• created_type (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• last_message (Annotated[str, Strict(strict=True)] | None)

• last_state (ControlChangeState | None)

• retries (Annotated[int, Strict(strict=True)] | None)

• timeout (Annotated[int, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• from_ (ControlChangeFrom | None)

• reported (ControlChangeReported | None)

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• resource (KRN)

• status_log (list[ControlChangeGetStatus] | None)

• timestamp (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeRangeGetPaginatedResponseCursor(**kwargs)

ControlChangeRangeGetPaginatedResponseCursor object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeRangeGetPaginatedResponseLimits(**kwargs)

ControlChangeRangeGetPaginatedResponseLimits object.

Parameters:

• data (list[ControlChangeGet] | None) – Optional[list[ControlChangeGet]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[ControlChangeGet] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ControlChangeRangeGetPaginatedResponseStream(**kwargs)

ControlChangeRangeGetPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• created_type (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• last_message (Annotated[str, Strict(strict=True)] | None)

• last_state (ControlChangeState | None)

• retries (Annotated[int, Strict(strict=True)] | None)

• timeout (Annotated[int, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• from_ (ControlChangeFrom | None)

• reported (ControlChangeReported | None)

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• resource (KRN)

• status_log (list[ControlChangeGetStatus] | None)

• timestamp (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionCreate(**kwargs)

CustomActionCreate object.

Parameters:

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• timestamp (datetime | None)

• created (datetime)

• created_by (KRN)

• updated (datetime)

• updated_by (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsListPaginatedResponseCursor(**kwargs)

CustomActionsListPaginatedResponseCursor object.

Parameters:

• data (list[CustomAction] | None) – Optional[list[type_1.CustomAction]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.CustomAction] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsListPaginatedResponseLimits(**kwargs)

CustomActionsListPaginatedResponseLimits object.

Parameters:

• data (list[CustomAction] | None) – Optional[list[type_1.CustomAction]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.CustomAction] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsListPaginatedResponseStream(**kwargs)

CustomActionsListPaginatedResponseStream object.

Parameters:

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• timestamp (datetime | None)

• created (datetime)

• created_by (KRN)

• updated (datetime)

• updated_by (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionGet(**kwargs)

CustomActionGet object.

Parameters:

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• timestamp (datetime | None)

• created (datetime)

• created_by (KRN)

• updated (datetime)

• updated_by (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionUpdate(**kwargs)

CustomActionUpdate object.

Parameters:

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• timestamp (datetime | None)

• created (datetime)

• created_by (KRN)

• updated (datetime)

• updated_by (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsSyncGet(**kwargs)

CustomActionsSyncGet object.

Parameters:

• pending (list[CustomAction] | None) – Optional[list[type_1.CustomAction]]

• kwargs (Any)

pending: list[type_1.CustomAction] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsSyncListPaginatedResponseCursor(**kwargs)

CustomActionsSyncListPaginatedResponseCursor object.

Parameters:

• data (list[CustomAction] | None) – Optional[list[type_1.CustomAction]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.CustomAction] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsSyncListPaginatedResponseLimits(**kwargs)

CustomActionsSyncListPaginatedResponseLimits object.

Parameters:

• data (list[CustomAction] | None) – Optional[list[type_1.CustomAction]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.CustomAction] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsSyncListPaginatedResponseStream(**kwargs)

CustomActionsSyncListPaginatedResponseStream object.

Parameters:

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• id (UUID)

• timestamp (datetime | None)

• created (datetime)

• created_by (KRN)

• updated (datetime)

• updated_by (KRN)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypeCreate(**kwargs)

CustomActionsTypeCreate object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypesListPaginatedCursor(**kwargs)

CustomActionsTypesListPaginatedCursor object.

Parameters:

• data (list[CustomActionType] | None) – Optional[list[type_1.CustomActionType]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.CustomActionType] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypesListPaginatedLimits(**kwargs)

CustomActionsTypesListPaginatedLimits object.

Parameters:

• data (list[CustomActionType] | None) – Optional[list[type_1.CustomActionType]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.CustomActionType] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypesListPaginatedStream(**kwargs)

CustomActionsTypesListPaginatedStream object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypeGet(**kwargs)

CustomActionsTypeGet object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.CustomActionsTypeUpdate(**kwargs)

CustomActionsTypeUpdate object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityCreate(**kwargs)

DataQualityCreate object.

Parameters:

• resource (KRN)

• configurations (Configurations)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityGet(**kwargs)

DataQualityGet object.

Parameters:

• resource (KRN)

• configurations (Configurations)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityUpdate(**kwargs)

DataQualityUpdate object.

Parameters:

• resource (KRN)

• configurations (Configurations)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityListPaginatedResponseCursor(**kwargs)

DataQualityListPaginatedResponseCursor object.

Parameters:

• data (list[DataQuality] | None) – Optional[list[type_1.DataQuality]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.DataQuality] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityListPaginatedResponseLimits(**kwargs)

DataQualityListPaginatedResponseLimits object.

Parameters:

• data (list[DataQuality] | None) – Optional[list[type_1.DataQuality]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.DataQuality] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityListPaginatedResponseStream(**kwargs)

DataQualityListPaginatedResponseStream object.

Parameters:

• resource (KRN)

• configurations (Configurations)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricCreate(**kwargs)

DataQualityMetricCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• description (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricGet(**kwargs)

DataQualityMetricGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• description (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricUpdate(**kwargs)

DataQualityMetricUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• description (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricsListPaginatedResponseCursor(**kwargs)

DataQualityMetricsListPaginatedResponseCursor object.

Parameters:

• data (list[DataQualityMetric] | None) – Optional[list[type_1.DataQualityMetric]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.DataQualityMetric] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricsListPaginatedResponseLimits(**kwargs)

DataQualityMetricsListPaginatedResponseLimits object.

Parameters:

• data (list[DataQualityMetric] | None) – Optional[list[type_1.DataQualityMetric]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.DataQualityMetric] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityMetricsListPaginatedResponseStream(**kwargs)

DataQualityMetricsListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• description (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• created (datetime | None)

• created_by (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityData(**kwargs)

DataQualityData object.

Parameters:

• kelvin_stale_detection (list[SimulationData] | None) – Optional[list[type_1.SimulationData]]

• kelvin_out_of_range_detection (list[SimulationData] | None) – Optional[list[type_1.SimulationData]]

• kelvin_outlier_detection (list[SimulationData] | None) – Optional[list[type_1.SimulationData]]

• kelvin_data_availability (list[SimulationData] | None) – Optional[list[type_1.SimulationData]]

• kwargs (Any)

kelvin_stale_detection: list[type_1.SimulationData] | None

kelvin_out_of_range_detection: list[type_1.SimulationData] | None

kelvin_outlier_detection: list[type_1.SimulationData] | None

kelvin_data_availability: list[type_1.SimulationData] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualitySimulate(**kwargs)

DataQualitySimulate object.

Parameters:

• timeseries_data (list[SimulationData] | None) – Optional[list[type_1.SimulationData]]

• data_quality_data (DataQualityData | None) – Optional[DataQualityData]

• kwargs (Any)

timeseries_data: list[type_1.SimulationData] | None

data_quality_data: DataQualityData | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataQualityStatistics(**kwargs)

DataQualityStatistics object.

Parameters:

• good_data_percentage (Annotated[float, Strict(strict=True)] | None) – Optional[StrictFloat]

• good_data_count (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• good_data_over_time (list[StatisticsData] | None) – Optional[list[type_1.StatisticsData]]

• bad_data_percentage (Annotated[float, Strict(strict=True)] | None) – Optional[StrictFloat]

• bad_data_count (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• bad_data_over_time (list[StatisticsData] | None) – Optional[list[type_1.StatisticsData]]

• kwargs (Any)

good_data_percentage: StrictFloat | None

good_data_count: StrictInt | None

good_data_over_time: list[type_1.StatisticsData] | None

bad_data_percentage: StrictFloat | None

bad_data_count: StrictInt | None

bad_data_over_time: list[type_1.StatisticsData] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsDataTypesListPaginatedResponseCursor(**kwargs)

DataStreamsDataTypesListPaginatedResponseCursor object.

Parameters:

• data (list[DataStreamDataType] | None) – Optional[list[type_1.DataStreamDataType]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.DataStreamDataType] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsDataTypesListPaginatedResponseLimits(**kwargs)

DataStreamsDataTypesListPaginatedResponseLimits object.

Parameters:

• data (list[DataStreamDataType] | None) – Optional[list[type_1.DataStreamDataType]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.DataStreamDataType] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsDataTypesListPaginatedResponseStream(**kwargs)

DataStreamsDataTypesListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamSemanticTypeCreate(**kwargs)

DataStreamSemanticTypeCreate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamSemanticTypeUpdate(**kwargs)

DataStreamSemanticTypeUpdate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamSemanticTypeGet(**kwargs)

DataStreamSemanticTypeGet object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsSemanticTypesListPaginatedResponseCursor(**kwargs)

DataStreamsSemanticTypesListPaginatedResponseCursor object.

Parameters:

• data (list[DataStreamSemanticType] | None) – Optional[list[type_1.DataStreamSemanticType]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.DataStreamSemanticType] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsSemanticTypesListPaginatedResponseLimits(**kwargs)

DataStreamsSemanticTypesListPaginatedResponseLimits object.

Parameters:

• data (list[DataStreamSemanticType] | None) – Optional[list[type_1.DataStreamSemanticType]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.DataStreamSemanticType] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsSemanticTypesListPaginatedResponseStream(**kwargs)

DataStreamsSemanticTypesListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamUnitCreate(**kwargs)

DataStreamUnitCreate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• symbol (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamUnitUpdate(**kwargs)

DataStreamUnitUpdate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• symbol (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamUnitGet(**kwargs)

DataStreamUnitGet object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• symbol (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsUnitsListPaginatedResponseCursor(**kwargs)

DataStreamsUnitsListPaginatedResponseCursor object.

Parameters:

• data (list[Unit] | None) – Optional[list[type_1.Unit]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Unit] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsUnitsListPaginatedResponseLimits(**kwargs)

DataStreamsUnitsListPaginatedResponseLimits object.

Parameters:

• data (list[Unit] | None) – Optional[list[type_1.Unit]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Unit] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsUnitsListPaginatedResponseStream(**kwargs)

DataStreamsUnitsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• symbol (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InUseByItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.responses.DataStream(**kwargs)

DataStream object.

Parameters:

• created (datetime | None) – Optional[datetime]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type_name (DataType | None) – Optional[enum.DataType]

• semantic_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (DataStreamType | None) – Optional[enum.DataStreamType]

• unit_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• is_protected (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• in_use_by (list[KRN] | None) – Optional[list[KRN]]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

description: StrictStr | None

name: StrictStr | None

data_type_name: enum.DataType | None

semantic_type_name: StrictStr | None

title: StrictStr | None

type: enum.DataStreamType | None

unit_name: StrictStr | None

is_protected: StrictBool | None

in_use_by: list[KRN] | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamCreate(**kwargs)

DataStreamCreate object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• semantic_type_name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (DataStreamType | None)

• unit_name (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamUpdate(**kwargs)

DataStreamUpdate object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• semantic_type_name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (DataStreamType | None)

• unit_name (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamGet(**kwargs)

DataStreamGet object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• semantic_type_name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (DataStreamType | None)

• unit_name (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsListPaginatedResponseCursor(**kwargs)

DataStreamsListPaginatedResponseCursor object.

Parameters:

• data (list[DataStream] | None) – Optional[list[DataStream]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[DataStream] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsListPaginatedResponseLimits(**kwargs)

DataStreamsListPaginatedResponseLimits object.

Parameters:

• data (list[DataStream] | None) – Optional[list[DataStream]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[DataStream] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamsListPaginatedResponseStream(**kwargs)

DataStreamsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• data_type_name (DataType | None)

• semantic_type_name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (DataStreamType | None)

• unit_name (Annotated[str, Strict(strict=True)] | None)

• is_protected (Annotated[bool, Strict(strict=True)] | None)

• in_use_by (list[KRN] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Context(**kwargs)

Context object.

Parameters:

• created (datetime | None) – Optional[datetime]

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• writable (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

created: datetime | None

resource: KRN | None

source: KRN | None

updated: datetime | None

writable: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamContext(**kwargs)

DataStreamContext object.

Parameters:

• context (list[Context] | None) – Optional[list[Context]]

• created (datetime | None) – Optional[datetime]

• datastream_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

context: list[Context] | None

created: datetime | None

datastream_name: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamContextGet(**kwargs)

DataStreamContextGet object.

Parameters:

• context (list[Context] | None)

• created (datetime | None)

• datastream_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamContextsListPaginatedResponseCursor(**kwargs)

DataStreamContextsListPaginatedResponseCursor object.

Parameters:

• data (list[DataStreamContext] | None) – Optional[list[DataStreamContext]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[DataStreamContext] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamContextsListPaginatedResponseLimits(**kwargs)

DataStreamContextsListPaginatedResponseLimits object.

Parameters:

• data (list[DataStreamContext] | None) – Optional[list[DataStreamContext]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[DataStreamContext] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataStreamContextsListPaginatedResponseStream(**kwargs)

DataStreamContextsListPaginatedResponseStream object.

Parameters:

• context (list[Context] | None)

• created (datetime | None)

• datastream_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagCreate(**kwargs)

DataTagCreate object.

Parameters:

• id (UUID | None)

• start_date (datetime | None)

• end_date (datetime | None)

• tag_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• source (KRN | None)

• description (Annotated[str, Strict(strict=True)] | None)

• contexts (list[KRN] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagUpdate(**kwargs)

DataTagUpdate object.

Parameters:

• id (UUID | None)

• start_date (datetime | None)

• end_date (datetime | None)

• tag_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• source (KRN | None)

• description (Annotated[str, Strict(strict=True)] | None)

• contexts (list[KRN] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagGet(**kwargs)

DataTagGet object.

Parameters:

• id (UUID | None)

• start_date (datetime | None)

• end_date (datetime | None)

• tag_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• source (KRN | None)

• description (Annotated[str, Strict(strict=True)] | None)

• contexts (list[KRN] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagListPaginatedResponseCursor(**kwargs)

DataTagListPaginatedResponseCursor object.

Parameters:

• data (list[DataTag] | None) – Optional[list[type_1.DataTag]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.DataTag] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagListPaginatedResponseLimits(**kwargs)

DataTagListPaginatedResponseLimits object.

Parameters:

• data (list[DataTag] | None) – Optional[list[type_1.DataTag]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.DataTag] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.DataTagListPaginatedResponseStream(**kwargs)

DataTagListPaginatedResponseStream object.

Parameters:

• id (UUID | None)

• start_date (datetime | None)

• end_date (datetime | None)

• tag_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• source (KRN | None)

• description (Annotated[str, Strict(strict=True)] | None)

• contexts (list[KRN] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagCreate(**kwargs)

TagCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagUpdate(**kwargs)

TagUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagGet(**kwargs)

TagGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagListPaginatedResponseCursor(**kwargs)

TagListPaginatedResponseCursor object.

Parameters:

• data (list[Tag] | None) – Optional[list[type_1.Tag]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Tag] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagListPaginatedResponseLimits(**kwargs)

TagListPaginatedResponseLimits object.

Parameters:

• data (list[Tag] | None) – Optional[list[type_1.Tag]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Tag] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TagListPaginatedResponseStream(**kwargs)

TagListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventCreate(**kwargs)

EventCreate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• id (UUID | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventGet(**kwargs)

EventGet object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• id (UUID | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventsListPaginatedResponseCursor(**kwargs)

EventsListPaginatedResponseCursor object.

Parameters:

• data (list[Event] | None) – Optional[list[type_1.Event]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Event] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventsListPaginatedResponseLimits(**kwargs)

EventsListPaginatedResponseLimits object.

Parameters:

• data (list[Event] | None) – Optional[list[type_1.Event]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Event] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventsListPaginatedResponseStream(**kwargs)

EventsListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• id (UUID | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.EventUpdate(**kwargs)

EventUpdate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• id (UUID | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.FileUpload(**kwargs)

FileUpload object.

Parameters:

• file_id (Annotated[str, Strict(strict=True)] | None)

• file_name (Annotated[str, Strict(strict=True)] | None)

• file_size (Annotated[int, Strict(strict=True)] | None)

• checksum (Annotated[str, Strict(strict=True)] | None)

• source (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• metadata (dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.FilesListPaginatedCursor(**kwargs)

FilesListPaginatedCursor object.

Parameters:

• data (list[FileStorage] | None) – Optional[list[type_1.FileStorage]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.FileStorage] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.FilesListPaginatedLimits(**kwargs)

FilesListPaginatedLimits object.

Parameters:

• data (list[FileStorage] | None) – Optional[list[type_1.FileStorage]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.FileStorage] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.FilesListPaginatedStream(**kwargs)

FilesListPaginatedStream object.

Parameters:

• file_id (Annotated[str, Strict(strict=True)] | None)

• file_name (Annotated[str, Strict(strict=True)] | None)

• file_size (Annotated[int, Strict(strict=True)] | None)

• checksum (Annotated[str, Strict(strict=True)] | None)

• source (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• metadata (dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.FileGet(**kwargs)

FileGet object.

Parameters:

• file_id (Annotated[str, Strict(strict=True)] | None)

• file_name (Annotated[str, Strict(strict=True)] | None)

• file_size (Annotated[int, Strict(strict=True)] | None)

• checksum (Annotated[str, Strict(strict=True)] | None)

• source (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• metadata (dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailCreate(**kwargs)

GuardrailCreate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• resource (KRN)

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumber | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailGet(**kwargs)

GuardrailGet object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• resource (KRN)

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumber | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailUpdate(**kwargs)

GuardrailUpdate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• resource (KRN)

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumber | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailsListPaginatedResponseCursor(**kwargs)

GuardrailsListPaginatedResponseCursor object.

Parameters:

• data (list[GuardrailModel] | None) – Optional[list[type_1.GuardrailModel]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.GuardrailModel] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailsListPaginatedResponseLimits(**kwargs)

GuardrailsListPaginatedResponseLimits object.

Parameters:

• data (list[GuardrailModel] | None) – Optional[list[type_1.GuardrailModel]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.GuardrailModel] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GuardrailsListPaginatedResponseStream(**kwargs)

GuardrailsListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• resource (KRN)

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumber | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.BulkGuardrailsCreate(**kwargs)

BulkGuardrailsCreate object.

Parameters:

• data (list[GuardrailModel] | None) – Optional[list[type_1.GuardrailModel]]

• kwargs (Any)

data: list[type_1.GuardrailModel] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceAuditLogGetItem(**kwargs)

InstanceAuditLogGetItem object.

Parameters:

• action (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• id (Annotated[int, Strict(strict=True)] | None)

• identifier (Annotated[str, Strict(strict=True)] | None)

• meta (dict[str, Any] | None)

• namespace (Annotated[str, Strict(strict=True)] | None)

• request_id (Annotated[str, Strict(strict=True)] | None)

• user_id (UUID | None)

• username (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceAuditLogsListPaginatedResponseCursor(**kwargs)

InstanceAuditLogsListPaginatedResponseCursor object.

Parameters:

• data (list[InstanceAuditLogGetItem] | None) – Optional[list[InstanceAuditLogGetItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[InstanceAuditLogGetItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceAuditLogsListPaginatedResponseLimits(**kwargs)

InstanceAuditLogsListPaginatedResponseLimits object.

Parameters:

• data (list[InstanceAuditLogGetItem] | None) – Optional[list[InstanceAuditLogGetItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[InstanceAuditLogGetItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceAuditLogsListPaginatedResponseStream(**kwargs)

InstanceAuditLogsListPaginatedResponseStream object.

Parameters:

• action (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• id (Annotated[int, Strict(strict=True)] | None)

• identifier (Annotated[str, Strict(strict=True)] | None)

• meta (dict[str, Any] | None)

• namespace (Annotated[str, Strict(strict=True)] | None)

• request_id (Annotated[str, Strict(strict=True)] | None)

• user_id (UUID | None)

• username (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceAuditLogGet(**kwargs)

InstanceAuditLogGet object.

Parameters:

• action (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• id (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• identifier (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• meta (dict[str, Any] | None) – Optional[dict[str, Any]]

• namespace (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• request_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• user_id (UUID | None) – Optional[UUID]

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

action: StrictStr | None

created: datetime | None

id: StrictInt | None

identifier: StrictStr | None

meta: dict[str, Any] | None

namespace: StrictStr | None

request_id: StrictStr | None

user_id: UUID | None

username: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsKelvinClusterGet(**kwargs)

InstanceSettingsKelvinClusterGet object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsKelvinClusterUpdate(**kwargs)

InstanceSettingsKelvinClusterUpdate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsListPaginatedResponseCursor(**kwargs)

InstanceSettingsListPaginatedResponseCursor object.

Parameters:

• data (list[InstanceSettings] | None) – Optional[list[type_1.InstanceSettings]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.InstanceSettings] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsListPaginatedResponseLimits(**kwargs)

InstanceSettingsListPaginatedResponseLimits object.

Parameters:

• data (list[InstanceSettings] | None) – Optional[list[type_1.InstanceSettings]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.InstanceSettings] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsListPaginatedResponseStream(**kwargs)

InstanceSettingsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsGet(**kwargs)

InstanceSettingsGet object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceSettingsUpdate(**kwargs)

InstanceSettingsUpdate object.

Parameters:

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ComponentStatus(**kwargs)

ComponentStatus object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

name: StrictStr | None

status: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.InstanceStatusGet(**kwargs)

InstanceStatusGet object.

Parameters:

• components (list[ComponentStatus] | None) – Optional[list[ComponentStatus]]

• status (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

components: list[ComponentStatus] | None

status: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersCreate(**kwargs)

OrchestrationClustersCreate object.

Parameters:

• created (datetime | None)

• forward_logs_buffer_size (Annotated[int, Strict(strict=True)] | None)

• forward_logs_enabled (Annotated[bool, Strict(strict=True)] | None)

• join_script (Annotated[str, Strict(strict=True)] | None)

• download_provision_script (Annotated[str, Strict(strict=True)] | None)

• ha_mode (Annotated[bool, Strict(strict=True)] | None)

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None)

• last_seen (datetime | None)

• manifests_scrape_enabled (Annotated[bool, Strict(strict=True)] | None)

• manifests_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• provision_script (Annotated[str, Strict(strict=True)] | None)

• ready (Annotated[bool, Strict(strict=True)] | None)

• service_account_token (Annotated[str, Strict(strict=True)] | None)

• status (OrchestrationClusterStatus | None)

• sync_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_buffer_size (Annotated[int, Strict(strict=True)] | None)

• telemetry_enabled (Annotated[bool, Strict(strict=True)] | None)

• telemetry_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_alerts_enabled (Annotated[bool, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (ClusterType | None)

• updated (datetime | None)

• upgrade_instantly_apply (Annotated[bool, Strict(strict=True)] | None)

• upgrade_pre_download (Annotated[bool, Strict(strict=True)] | None)

• upgrade_status (UpgradeStatus | None)

• version (Version | None)

• edge_apps (ClusterEdgeApps | None)

• edge_options (ClusterEdgeOptions | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersCreateItem(**kwargs)

OrchestrationClustersCreateItem object.

Parameters:

• created (datetime | None) – Optional[datetime]

• last_seen (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kelvin_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• container_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ha_mode (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (OrchestrationClusterStatus | None) – Optional[enum.OrchestrationClusterStatus]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (ClusterType | None) – Optional[enum.ClusterType]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

last_seen: datetime | None

name: StrictStr | None

ready: StrictBool | None

kelvin_version: StrictStr | None

container_version: StrictStr | None

ha_mode: StrictBool | None

ha_mode_warning: StrictStr | None

status: enum.OrchestrationClusterStatus | None

title: StrictStr | None

type: enum.ClusterType | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersListPaginatedResponseCursor(**kwargs)

OrchestrationClustersListPaginatedResponseCursor object.

Parameters:

• data (list[OrchestrationClustersCreateItem] | None) – Optional[list[OrchestrationClustersCreateItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[OrchestrationClustersCreateItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersListPaginatedResponseLimits(**kwargs)

OrchestrationClustersListPaginatedResponseLimits object.

Parameters:

• data (list[OrchestrationClustersCreateItem] | None) – Optional[list[OrchestrationClustersCreateItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[OrchestrationClustersCreateItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersListPaginatedResponseStream(**kwargs)

OrchestrationClustersListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• last_seen (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• ready (Annotated[bool, Strict(strict=True)] | None)

• kelvin_version (Annotated[str, Strict(strict=True)] | None)

• container_version (Annotated[str, Strict(strict=True)] | None)

• ha_mode (Annotated[bool, Strict(strict=True)] | None)

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None)

• status (OrchestrationClusterStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (ClusterType | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersGet(**kwargs)

OrchestrationClustersGet object.

Parameters:

• created (datetime | None)

• forward_logs_buffer_size (Annotated[int, Strict(strict=True)] | None)

• forward_logs_enabled (Annotated[bool, Strict(strict=True)] | None)

• join_script (Annotated[str, Strict(strict=True)] | None)

• download_provision_script (Annotated[str, Strict(strict=True)] | None)

• ha_mode (Annotated[bool, Strict(strict=True)] | None)

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None)

• last_seen (datetime | None)

• manifests_scrape_enabled (Annotated[bool, Strict(strict=True)] | None)

• manifests_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• provision_script (Annotated[str, Strict(strict=True)] | None)

• ready (Annotated[bool, Strict(strict=True)] | None)

• service_account_token (Annotated[str, Strict(strict=True)] | None)

• status (OrchestrationClusterStatus | None)

• sync_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_buffer_size (Annotated[int, Strict(strict=True)] | None)

• telemetry_enabled (Annotated[bool, Strict(strict=True)] | None)

• telemetry_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_alerts_enabled (Annotated[bool, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (ClusterType | None)

• updated (datetime | None)

• upgrade_instantly_apply (Annotated[bool, Strict(strict=True)] | None)

• upgrade_pre_download (Annotated[bool, Strict(strict=True)] | None)

• upgrade_status (UpgradeStatus | None)

• version (Version | None)

• edge_apps (ClusterEdgeApps | None)

• edge_options (ClusterEdgeOptions | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersCreateManifestImageItem(**kwargs)

OrchestrationClustersCreateManifestImageItem object.

Parameters:

• args (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• path (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

args: StrictStr | None

path: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersCreateManifestItem(**kwargs)

OrchestrationClustersCreateManifestItem object.

Parameters:

• content (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• file_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

content: StrictStr | None

file_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersCreateManifestUpgrade(**kwargs)

OrchestrationClustersCreateManifestUpgrade object.

Parameters:

• download_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• upgrade_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

download_type: StrictStr | None

upgrade_type: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersManifestsGet(**kwargs)

OrchestrationClustersManifestsGet object.

Parameters:

• images (list[OrchestrationClustersCreateManifestImageItem] | None) – Optional[list[OrchestrationClustersCreateManifestImageItem]]

• manifests (list[OrchestrationClustersCreateManifestItem] | None) – Optional[list[OrchestrationClustersCreateManifestItem]]

• revision (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• upgrade (OrchestrationClustersCreateManifestUpgrade | None) – Optional[OrchestrationClustersCreateManifestUpgrade]

• kwargs (Any)

images: list[OrchestrationClustersCreateManifestImageItem] | None

manifests: list[OrchestrationClustersCreateManifestItem] | None

revision: StrictStr | None

upgrade: OrchestrationClustersCreateManifestUpgrade | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodesGetItem(**kwargs)

OrchestrationClustersNodesGetItem object.

Parameters:

• created (datetime | None) – Optional[datetime]

• last_seen (datetime | None) – Optional[datetime]

• main (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (OrchestrationNodeStatus | None) – Optional[enum.OrchestrationNodeStatus]

• updated (datetime | None) – Optional[datetime]

• warnings (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• kwargs (Any)

created: datetime | None

last_seen: datetime | None

main: StrictBool | None

name: StrictStr | None

status: enum.OrchestrationNodeStatus | None

updated: datetime | None

warnings: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodeListPaginatedResponseCursor(**kwargs)

OrchestrationClustersNodeListPaginatedResponseCursor object.

Parameters:

• data (list[OrchestrationClustersNodesGetItem] | None) – Optional[list[OrchestrationClustersNodesGetItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[OrchestrationClustersNodesGetItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodeListPaginatedResponseLimits(**kwargs)

OrchestrationClustersNodeListPaginatedResponseLimits object.

Parameters:

• data (list[OrchestrationClustersNodesGetItem] | None) – Optional[list[OrchestrationClustersNodesGetItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[OrchestrationClustersNodesGetItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodeListPaginatedResponseStream(**kwargs)

OrchestrationClustersNodeListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• last_seen (datetime | None)

• main (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• status (OrchestrationNodeStatus | None)

• updated (datetime | None)

• warnings (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodesGetConditionItem(**kwargs)

OrchestrationClustersNodesGetConditionItem object.

Parameters:

• lastHeartbeatTime (datetime | None) – Optional[datetime]

• lastTransitionTime (datetime | None) – Optional[datetime]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• reason (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status_message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

lastHeartbeatTime: datetime | None

lastTransitionTime: datetime | None

message: StrictStr | None

name: StrictStr | None

reason: StrictStr | None

status: StrictStr | None

status_message: StrictStr | None

type: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodesGetSystemInfo(**kwargs)

OrchestrationClustersNodesGetSystemInfo object.

Parameters:

• architecture (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• boot_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• container_runtime_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• host_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kernel_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kube_proxy_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kubelet_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• machine_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• operating_system (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• os_image (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• system_uuid (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

architecture: StrictStr | None

boot_id: StrictStr | None

container_runtime_version: StrictStr | None

host_name: StrictStr | None

kernel_version: StrictStr | None

kube_proxy_version: StrictStr | None

kubelet_version: StrictStr | None

machine_id: StrictStr | None

operating_system: StrictStr | None

os_image: StrictStr | None

system_uuid: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.NetworkInfoItem(**kwargs)

NetworkInfoItem object.

Parameters:

• interface (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ipv4 (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• ipv6 (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• dns (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

interface: StrictStr | None

ipv4: list[StrictStr] | None

ipv6: list[StrictStr] | None

dns: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersNodesGet(**kwargs)

OrchestrationClustersNodesGet object.

Parameters:

• capacity (NodeCapacity | None) – Optional[type_1.NodeCapacity]

• conditions (list[OrchestrationClustersNodesGetConditionItem] | None) – Optional[list[OrchestrationClustersNodesGetConditionItem]]

• created (datetime | None) – Optional[datetime]

• hostname (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• internal_ip (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• k8s_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• labels (dict[str, Annotated[str, Strict(strict=True)]] | None) – Optional[dict[str, StrictStr]]

• last_seen (datetime | None) – Optional[datetime]

• main (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• network_info (list[NetworkInfoItem] | None) – Optional[list[NetworkInfoItem]]

• status (OrchestrationNodeStatus | None) – Optional[enum.OrchestrationNodeStatus]

• system_info (OrchestrationClustersNodesGetSystemInfo | None) – Optional[OrchestrationClustersNodesGetSystemInfo]

• updated (datetime | None) – Optional[datetime]

• warnings (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

capacity: type_1.NodeCapacity | None

conditions: list[OrchestrationClustersNodesGetConditionItem] | None

created: datetime | None

hostname: StrictStr | None

internal_ip: StrictStr | None

k8s_version: StrictStr | None

labels: dict[str, StrictStr] | None

last_seen: datetime | None

main: StrictBool | None

name: StrictStr | None

network_info: list[NetworkInfoItem] | None

status: enum.OrchestrationNodeStatus | None

system_info: OrchestrationClustersNodesGetSystemInfo | None

updated: datetime | None

warnings: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ServiceItem(**kwargs)

ServiceItem object.

Parameters:

• address (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• network_interface (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• service_type (ServiceType | None) – Optional[enum.ServiceType]

• updated (datetime | None) – Optional[datetime]

• workload_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

address: StrictStr | None

created: datetime | None

name: StrictStr | None

network_interface: StrictStr | None

service_type: enum.ServiceType | None

updated: datetime | None

workload_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersServiceListPaginatedResponseCursor(**kwargs)

OrchestrationClustersServiceListPaginatedResponseCursor object.

Parameters:

• data (list[ServiceItem] | None) – Optional[list[ServiceItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[ServiceItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersServiceListPaginatedResponseLimits(**kwargs)

OrchestrationClustersServiceListPaginatedResponseLimits object.

Parameters:

• data (list[ServiceItem] | None) – Optional[list[ServiceItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[ServiceItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersServiceListPaginatedResponseStream(**kwargs)

OrchestrationClustersServiceListPaginatedResponseStream object.

Parameters:

• address (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• network_interface (Annotated[str, Strict(strict=True)] | None)

• service_type (ServiceType | None)

• updated (datetime | None)

• workload_name (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.OrchestrationClustersUpdate(**kwargs)

OrchestrationClustersUpdate object.

Parameters:

• created (datetime | None)

• forward_logs_buffer_size (Annotated[int, Strict(strict=True)] | None)

• forward_logs_enabled (Annotated[bool, Strict(strict=True)] | None)

• join_script (Annotated[str, Strict(strict=True)] | None)

• download_provision_script (Annotated[str, Strict(strict=True)] | None)

• ha_mode (Annotated[bool, Strict(strict=True)] | None)

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None)

• last_seen (datetime | None)

• manifests_scrape_enabled (Annotated[bool, Strict(strict=True)] | None)

• manifests_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• provision_script (Annotated[str, Strict(strict=True)] | None)

• ready (Annotated[bool, Strict(strict=True)] | None)

• service_account_token (Annotated[str, Strict(strict=True)] | None)

• status (OrchestrationClusterStatus | None)

• sync_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_buffer_size (Annotated[int, Strict(strict=True)] | None)

• telemetry_enabled (Annotated[bool, Strict(strict=True)] | None)

• telemetry_scrape_interval (Annotated[int, Strict(strict=True)] | None)

• telemetry_alerts_enabled (Annotated[bool, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (ClusterType | None)

• updated (datetime | None)

• upgrade_instantly_apply (Annotated[bool, Strict(strict=True)] | None)

• upgrade_pre_download (Annotated[bool, Strict(strict=True)] | None)

• upgrade_status (UpgradeStatus | None)

• version (Version | None)

• edge_apps (ClusterEdgeApps | None)

• edge_options (ClusterEdgeOptions | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertyCreate(**kwargs)

PropertyCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• primitive_type (PropertyType | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertyGet(**kwargs)

PropertyGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• primitive_type (PropertyType | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertiesListPaginatedResponseCursor(**kwargs)

PropertiesListPaginatedResponseCursor object.

Parameters:

• data (list[PropertyDefinition] | None) – Optional[list[type_1.PropertyDefinition]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.PropertyDefinition] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertiesListPaginatedResponseLimits(**kwargs)

PropertiesListPaginatedResponseLimits object.

Parameters:

• data (list[PropertyDefinition] | None) – Optional[list[type_1.PropertyDefinition]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.PropertyDefinition] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertiesListPaginatedResponseStream(**kwargs)

PropertiesListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• primitive_type (PropertyType | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertyUniqueValuesGet(**kwargs)

PropertyUniqueValuesGet object.

Parameters:

• properties (dict[str, list[Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]]] | None) – Optional[dict[str, list[Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]]

• kwargs (Any)

properties: dict[str, list[StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PropertyValuesGet(**kwargs)

PropertyValuesGet object.

Parameters:

• resource_values (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]

• kwargs (Any)

resource_values: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RangeGetPropertyPaginatedResponseCursor(**kwargs)

RangeGetPropertyPaginatedResponseCursor object.

Parameters:

• data (list[PropertyValueHistory] | None) – Optional[list[type_1.PropertyValueHistory]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.PropertyValueHistory] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RangeGetPropertyPaginatedResponseLimits(**kwargs)

RangeGetPropertyPaginatedResponseLimits object.

Parameters:

• data (list[PropertyValueHistory] | None) – Optional[list[type_1.PropertyValueHistory]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.PropertyValueHistory] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RangeGetPropertyPaginatedResponseStream(**kwargs)

RangeGetPropertyPaginatedResponseStream object.

Parameters:

• property_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• timestamp (datetime | None)

• source (Annotated[str, Strict(strict=True)] | None)

• value (dict[str, Any] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationClustering(**kwargs)

RecommendationClustering object.

Parameters:

• count (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• recommendations_ids (list[UUID] | None) – Optional[list[UUID]]

• time_bucket_start (datetime | None) – Optional[datetime]

• kwargs (Any)

count: StrictInt | None

recommendations_ids: list[UUID] | None

time_bucket_start: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationCreate(**kwargs)

RecommendationCreate object.

Parameters:

• actions (RecommendationActionsCreate | None) – Optional[type_1.RecommendationActionsCreate]

• state (RecommendationStateCreate | None) – Optional[enum.RecommendationStateCreate]

• id (UUID | None) – Optional[UUID]

• type_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• source (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• kwargs (Any)

actions: type_1.RecommendationActionsCreate | None

state: enum.RecommendationStateCreate | None

id: UUID | None

type_title: StrictStr | None

created: datetime | None

source: KRN | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationLastGetPaginatedResponseCursor(**kwargs)

RecommendationLastGetPaginatedResponseCursor object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationLastGetPaginatedResponseLimits(**kwargs)

RecommendationLastGetPaginatedResponseLimits object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationLastGetPaginatedResponseStream(**kwargs)

RecommendationLastGetPaginatedResponseStream object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• actions (RecommendationActions | None)

• id (UUID | None)

• type_title (Annotated[str, Strict(strict=True)] | None)

• message (Annotated[str, Strict(strict=True)] | None)

• state (RecommendationState | None)

• created (datetime | None)

• source (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationsListPaginatedResponseCursor(**kwargs)

RecommendationsListPaginatedResponseCursor object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationsListPaginatedResponseLimits(**kwargs)

RecommendationsListPaginatedResponseLimits object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationsListPaginatedResponseStream(**kwargs)

RecommendationsListPaginatedResponseStream object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• actions (RecommendationActions | None)

• id (UUID | None)

• type_title (Annotated[str, Strict(strict=True)] | None)

• message (Annotated[str, Strict(strict=True)] | None)

• state (RecommendationState | None)

• created (datetime | None)

• source (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationRangeGetPaginatedResponseCursor(**kwargs)

RecommendationRangeGetPaginatedResponseCursor object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationRangeGetPaginatedResponseLimits(**kwargs)

RecommendationRangeGetPaginatedResponseLimits object.

Parameters:

• data (list[Recommendation] | None) – Optional[list[type_1.Recommendation]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Recommendation] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationRangeGetPaginatedResponseStream(**kwargs)

RecommendationRangeGetPaginatedResponseStream object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• actions (RecommendationActions | None)

• id (UUID | None)

• type_title (Annotated[str, Strict(strict=True)] | None)

• message (Annotated[str, Strict(strict=True)] | None)

• state (RecommendationState | None)

• created (datetime | None)

• source (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypeCreate(**kwargs)

RecommendationTypeCreate object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypesListPaginatedCursor(**kwargs)

RecommendationTypesListPaginatedCursor object.

Parameters:

• data (list[RecommendationType] | None) – Optional[list[type_1.RecommendationType]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.RecommendationType] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypesListPaginatedLimits(**kwargs)

RecommendationTypesListPaginatedLimits object.

Parameters:

• data (list[RecommendationType] | None) – Optional[list[type_1.RecommendationType]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.RecommendationType] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypesListPaginatedStream(**kwargs)

RecommendationTypesListPaginatedStream object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypeGet(**kwargs)

RecommendationTypeGet object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationTypeUpdate(**kwargs)

RecommendationTypeUpdate object.

Parameters:

• created (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• metadata (dict[str, Any] | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RecommendationGet(**kwargs)

RecommendationGet object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• actions (RecommendationActions | None)

• id (UUID | None)

• type_title (Annotated[str, Strict(strict=True)] | None)

• message (Annotated[str, Strict(strict=True)] | None)

• state (RecommendationState | None)

• created (datetime | None)

• source (KRN | None)

• updated (datetime | None)

• updated_by (KRN | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretCreate(**kwargs)

SecretCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• updated_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

created: datetime | None

created_by: StrictStr | None

updated: datetime | None

updated_by: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretItem(**kwargs)

SecretItem object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• updated_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

created: datetime | None

created_by: StrictStr | None

updated: datetime | None

updated_by: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretsListPaginatedResponseCursor(**kwargs)

SecretsListPaginatedResponseCursor object.

Parameters:

• data (list[SecretItem] | None) – Optional[list[SecretItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[SecretItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretsListPaginatedResponseLimits(**kwargs)

SecretsListPaginatedResponseLimits object.

Parameters:

• data (list[SecretItem] | None) – Optional[list[SecretItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[SecretItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretsListPaginatedResponseStream(**kwargs)

SecretsListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SecretUpdate(**kwargs)

SecretUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• updated_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

created: datetime | None

created_by: StrictStr | None

updated: datetime | None

updated_by: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TimeseriesLastGet(**kwargs)

TimeseriesLastGet object.

Parameters:

• created (datetime | None)

• data_type (Annotated[str, Strict(strict=True)] | None)

• fields (list[Annotated[str, Strict(strict=True)]] | None)

• last_timestamp (datetime | None)

• last_value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• resource (KRN | None)

• source (KRN | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TimeseriesListPaginatedResponseCursor(**kwargs)

TimeseriesListPaginatedResponseCursor object.

Parameters:

• data (list[TimeseriesData] | None) – Optional[list[type_1.TimeseriesData]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.TimeseriesData] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TimeseriesListPaginatedResponseLimits(**kwargs)

TimeseriesListPaginatedResponseLimits object.

Parameters:

• data (list[TimeseriesData] | None) – Optional[list[type_1.TimeseriesData]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.TimeseriesData] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TimeseriesListPaginatedResponseStream(**kwargs)

TimeseriesListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• data_type (Annotated[str, Strict(strict=True)] | None)

• fields (list[Annotated[str, Strict(strict=True)]] | None)

• last_timestamp (datetime | None)

• last_value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• resource (KRN | None)

• source (KRN | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TimeseriesRangeGet(**kwargs)

TimeseriesRangeGet object.

Parameters:

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• resource (KRN | None) – Optional[KRN]

• timestamp (datetime | None) – Optional[datetime]

• kwargs (Any)

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

resource: KRN | None

timestamp: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserItem(**kwargs)

UserItem object.

Parameters:

• created (datetime | None) – Optional[datetime]

• email (EmailStr | None) – Optional[EmailStr]

• first_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• id (UUID | None) – Optional[UUID]

• last_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

created: datetime | None

email: EmailStr | None

first_name: StrictStr | None

id: UUID | None

last_name: StrictStr | None

username: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UsersListPaginatedResponseCursor(**kwargs)

UsersListPaginatedResponseCursor object.

Parameters:

• data (list[UserItem] | None) – Optional[list[UserItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[UserItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UsersListPaginatedResponseLimits(**kwargs)

UsersListPaginatedResponseLimits object.

Parameters:

• data (list[UserItem] | None) – Optional[list[UserItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[UserItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UsersListPaginatedResponseStream(**kwargs)

UsersListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• email (EmailStr | None)

• first_name (Annotated[str, Strict(strict=True)] | None)

• id (UUID | None)

• last_name (Annotated[str, Strict(strict=True)] | None)

• username (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Permission(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.responses.UserMeGet(**kwargs)

UserMeGet object.

Parameters:

• created (datetime | None) – Optional[datetime]

• email (EmailStr | None) – Optional[EmailStr]

• first_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• id (UUID | None) – Optional[UUID]

• last_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• permissions (list[Permission] | None) – Optional[list[Permission]]

• groups (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

created: datetime | None

email: EmailStr | None

first_name: StrictStr | None

id: UUID | None

last_name: StrictStr | None

permissions: list[Permission] | None

groups: list[StrictStr] | None

username: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserSettingsListPaginatedResponseCursor(**kwargs)

UserSettingsListPaginatedResponseCursor object.

Parameters:

• data (list[UserSetting] | None) – Optional[list[type_1.UserSetting]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.UserSetting] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserSettingsListPaginatedResponseLimits(**kwargs)

UserSettingsListPaginatedResponseLimits object.

Parameters:

• data (list[UserSetting] | None) – Optional[list[type_1.UserSetting]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.UserSetting] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserSettingsListPaginatedResponseStream(**kwargs)

UserSettingsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserSettingsGet(**kwargs)

UserSettingsGet object.

Parameters:

• created (datetime | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserSettingsUpdate(**kwargs)

UserSettingsUpdate object.

Parameters:

• created (datetime | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.UserGet(**kwargs)

UserGet object.

Parameters:

• created (datetime | None) – Optional[datetime]

• email (EmailStr | None) – Optional[EmailStr]

• first_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• id (UUID | None) – Optional[UUID]

• last_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

created: datetime | None

email: EmailStr | None

first_name: StrictStr | None

id: UUID | None

last_name: StrictStr | None

username: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SharedSettingsUpdate(**kwargs)

SharedSettingsUpdate object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SharedSettingsGet(**kwargs)

SharedSettingsGet object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SharedSettingsListPaginatedResponseCursor(**kwargs)

SharedSettingsListPaginatedResponseCursor object.

Parameters:

• data (list[SharedSetting] | None) – Optional[list[type_1.SharedSetting]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.SharedSetting] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SharedSettingsListPaginatedResponseLimits(**kwargs)

SharedSettingsListPaginatedResponseLimits object.

Parameters:

• data (list[SharedSetting] | None) – Optional[list[type_1.SharedSetting]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.SharedSetting] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.SharedSettingsListPaginatedResponseStream(**kwargs)

SharedSettingsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• created_by (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• setting_name (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• updated_by (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TaskCreate(**kwargs)

TaskCreate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resources (list[TaskResourceListItem] | None)

• definition (TaskDefinition | None)

• ui_metadata (TaskUIMetadata | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TaskGet(**kwargs)

TaskGet object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resources (list[TaskResourceListItem] | None)

• definition (TaskDefinition | None)

• ui_metadata (TaskUIMetadata | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TasksListPaginatedResponseCursor(**kwargs)

TasksListPaginatedResponseCursor object.

Parameters:

• data (list[Task] | None) – Optional[list[type_1.Task]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[type_1.Task] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TasksListPaginatedResponseLimits(**kwargs)

TasksListPaginatedResponseLimits object.

Parameters:

• data (list[Task] | None) – Optional[list[type_1.Task]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[type_1.Task] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TasksListPaginatedResponseStream(**kwargs)

TasksListPaginatedResponseStream object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resources (list[TaskResourceListItem] | None)

• definition (TaskDefinition | None)

• ui_metadata (TaskUIMetadata | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TaskUpdate(**kwargs)

TaskUpdate object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resources (list[TaskResourceListItem] | None)

• definition (TaskDefinition | None)

• ui_metadata (TaskUIMetadata | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.TaskResourcesAdd(**kwargs)

TaskResourcesAdd object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resources (list[TaskResourceListItem] | None)

• definition (TaskDefinition | None)

• ui_metadata (TaskUIMetadata | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Role(**kwargs)

Role object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Group(**kwargs)

Group object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• roles (list[Role] | None) – Optional[list[Role]]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

roles: list[Role] | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupCreate(**kwargs)

GroupCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• roles (list[Role] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupItem(**kwargs)

GroupItem object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupsListPaginatedResponseCursor(**kwargs)

GroupsListPaginatedResponseCursor object.

Parameters:

• data (list[GroupItem] | None) – Optional[list[GroupItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[GroupItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupsListPaginatedResponseLimits(**kwargs)

GroupsListPaginatedResponseLimits object.

Parameters:

• data (list[GroupItem] | None) – Optional[list[GroupItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[GroupItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupsListPaginatedResponseStream(**kwargs)

GroupsListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupGet(**kwargs)

GroupGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• roles (list[Role] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupUpdate(**kwargs)

GroupUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• roles (list[Role] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.GroupModel(**kwargs)

GroupModel object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RoleModel(**kwargs)

RoleModel object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• groups (list[GroupModel] | None) – Optional[list[GroupModel]]

• updated (datetime | None) – Optional[datetime]

• created (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

groups: list[GroupModel] | None

updated: datetime | None

created: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RoleCreate(**kwargs)

RoleCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• groups (list[GroupModel] | None)

• updated (datetime | None)

• created (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.PolicyName(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.responses.RoleItem(**kwargs)

RoleItem object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• policy_names (list[PolicyName] | None) – Optional[list[PolicyName]]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

policy_names: list[PolicyName] | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolesListPaginatedResponseCursor(**kwargs)

RolesListPaginatedResponseCursor object.

Parameters:

• data (list[RoleItem] | None) – Optional[list[RoleItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[RoleItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolesListPaginatedResponseLimits(**kwargs)

RolesListPaginatedResponseLimits object.

Parameters:

• data (list[RoleItem] | None) – Optional[list[RoleItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[RoleItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolesListPaginatedResponseStream(**kwargs)

RolesListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• policy_names (list[PolicyName] | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RoleGet(**kwargs)

RoleGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• groups (list[GroupModel] | None)

• updated (datetime | None)

• created (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RoleUpdate(**kwargs)

RoleUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• groups (list[GroupModel] | None)

• updated (datetime | None)

• created (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Rule(**kwargs)

Rule object.

Parameters:

• actions (list[RolePolicyAction] | None) – Optional[list[enum.RolePolicyAction]]

• condition (RolePolicyCondition | None) – Optional[type_1.RolePolicyCondition]

• kwargs (Any)

actions: list[enum.RolePolicyAction] | None

condition: type_1.RolePolicyCondition | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePolicy(**kwargs)

RolePolicy object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource_type (ResourceType | None) – Optional[enum.ResourceType]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• rule (Rule | None) – Optional[Rule]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

resource_type: enum.ResourceType | None

title: StrictStr | None

description: StrictStr | None

rule: Rule | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePolicyCreate(**kwargs)

RolePolicyCreate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• resource_type (ResourceType | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• rule (Rule | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePoliciesListPaginatedResponseCursor(**kwargs)

RolePoliciesListPaginatedResponseCursor object.

Parameters:

• data (list[RolePolicy] | None) – Optional[list[RolePolicy]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[RolePolicy] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePoliciesListPaginatedResponseLimits(**kwargs)

RolePoliciesListPaginatedResponseLimits object.

Parameters:

• data (list[RolePolicy] | None) – Optional[list[RolePolicy]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[RolePolicy] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePoliciesListPaginatedResponseStream(**kwargs)

RolePoliciesListPaginatedResponseStream object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• resource_type (ResourceType | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• rule (Rule | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePolicyGet(**kwargs)

RolePolicyGet object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• resource_type (ResourceType | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• rule (Rule | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.RolePolicyUpdate(**kwargs)

RolePolicyUpdate object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None)

• resource_type (ResourceType | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• rule (Rule | None)

• created (datetime | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppCreate(**kwargs)

LegacyAppCreate object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (LegacyAppType | None)

• updated (datetime | None)

• versions (list[LegacyAppVersion] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ErrorMessage(**kwargs)

ErrorMessage object.

Parameters:

• error_code (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• http_status_code (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• message (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• type (ErrorLegacyType | None) – Optional[enum.ErrorLegacyType]

• kwargs (Any)

error_code: StrictInt | None

http_status_code: StrictInt | None

message: list[StrictStr] | None

type: enum.ErrorLegacyType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppItem(**kwargs)

LegacyAppItem object.

Parameters:

• created (datetime | None) – Optional[datetime]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• latest_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (LegacyAppType | None) – Optional[enum.LegacyAppType]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

description: StrictStr | None

latest_version: StrictStr | None

name: StrictStr | None

title: StrictStr | None

type: enum.LegacyAppType | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppRegistryAppsListPaginatedResponseCursor(**kwargs)

LegacyAppRegistryAppsListPaginatedResponseCursor object.

Parameters:

• data (list[LegacyAppItem] | None) – Optional[list[LegacyAppItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

data: list[LegacyAppItem] | None

pagination: PaginationCursor | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppRegistryAppsListPaginatedResponseLimits(**kwargs)

LegacyAppRegistryAppsListPaginatedResponseLimits object.

Parameters:

• data (list[LegacyAppItem] | None) – Optional[list[LegacyAppItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

data: list[LegacyAppItem] | None

pagination: PaginationLimits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppRegistryAppsListPaginatedResponseStream(**kwargs)

LegacyAppRegistryAppsListPaginatedResponseStream object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (LegacyAppType | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppRegistryAppGet(**kwargs)

LegacyAppRegistryAppGet object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (LegacyAppType | None)

• updated (datetime | None)

• versions (list[LegacyAppVersion] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppUpdate(**kwargs)

LegacyAppUpdate object.

Parameters:

• created (datetime | None)

• description (Annotated[str, Strict(strict=True)] | None)

• latest_version (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• type (LegacyAppType | None)

• updated (datetime | None)

• versions (list[LegacyAppVersion] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyAppVersionGet(**kwargs)

LegacyAppVersionGet object.

Parameters:

• created (datetime | None)

• id (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• updated (datetime | None)

• version (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.BridgeDeploy(**kwargs)

BridgeDeploy object.

Parameters:

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• payload (AppYaml | None)

• status (WorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• workload_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.BridgeItem(**kwargs)

BridgeItem object.

Parameters:

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (WorkloadStatus | None) – Optional[type_1.WorkloadStatus]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• workload_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

cluster_name: StrictStr | None

created: datetime | None

enabled: StrictBool | None

name: StrictStr | None

node_name: StrictStr | None

status: type_1.WorkloadStatus | None

title: StrictStr | None

updated: datetime | None

workload_name: StrictStr | None

app_name: StrictStr | None

app_version: StrictStr | None

class kelvin.api.client.model.responses.BridgesListPaginatedResponseCursor(**kwargs)

BridgesListPaginatedResponseCursor object.

Parameters:

• data (list[BridgeItem] | None) – Optional[list[BridgeItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[BridgeItem] | None

pagination: PaginationCursor | None

class kelvin.api.client.model.responses.BridgesListPaginatedResponseLimits(**kwargs)

BridgesListPaginatedResponseLimits object.

Parameters:

• data (list[BridgeItem] | None) – Optional[list[BridgeItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[BridgeItem] | None

pagination: PaginationLimits | None

class kelvin.api.client.model.responses.BridgesListPaginatedResponseStream(**kwargs)

BridgesListPaginatedResponseStream object.

Parameters:

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• workload_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.BridgeGet(**kwargs)

BridgeGet object.

Parameters:

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• payload (AppYaml | None)

• status (WorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• workload_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParameterDefinitionItem(**kwargs)

ParameterDefinitionItem object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• last_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• primitive_type (ParameterType | None) – Optional[enum.ParameterType]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

app_name: StrictStr | None

created: datetime | None

last_title: StrictStr | None

name: StrictStr | None

primitive_type: enum.ParameterType | None

updated: datetime | None

class kelvin.api.client.model.responses.ParametersDefinitionsListPaginatedResponseCursor(**kwargs)

ParametersDefinitionsListPaginatedResponseCursor object.

Parameters:

• data (list[ParameterDefinitionItem] | None) – Optional[list[ParameterDefinitionItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[ParameterDefinitionItem] | None

pagination: PaginationCursor | None

class kelvin.api.client.model.responses.ParametersDefinitionsListPaginatedResponseLimits(**kwargs)

ParametersDefinitionsListPaginatedResponseLimits object.

Parameters:

• data (list[ParameterDefinitionItem] | None) – Optional[list[ParameterDefinitionItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[ParameterDefinitionItem] | None

pagination: PaginationLimits | None

class kelvin.api.client.model.responses.ParametersDefinitionsListPaginatedResponseStream(**kwargs)

ParametersDefinitionsListPaginatedResponseStream object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• last_title (Annotated[str, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• primitive_type (ParameterType | None)

• updated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParameterValueHistorianItem(**kwargs)

ParameterValueHistorianItem object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• comment (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• parameter_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• invalidated (datetime | None) – Optional[datetime]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

app_name: StrictStr | None

app_version: StrictStr | None

comment: StrictStr | None

created: datetime | None

parameter_name: StrictStr | None

resource: KRN | None

source: KRN | None

updated: datetime | None

value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

invalidated: datetime | None

class kelvin.api.client.model.responses.ResourceParametersListPaginatedResponseCursor(**kwargs)

ResourceParametersListPaginatedResponseCursor object.

Parameters:

• data (list[ParameterValueHistorianItem] | None) – Optional[list[ParameterValueHistorianItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[ParameterValueHistorianItem] | None

pagination: PaginationCursor | None

class kelvin.api.client.model.responses.ResourceParametersListPaginatedResponseLimits(**kwargs)

ResourceParametersListPaginatedResponseLimits object.

Parameters:

• data (list[ParameterValueHistorianItem] | None) – Optional[list[ParameterValueHistorianItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[ParameterValueHistorianItem] | None

pagination: PaginationLimits | None

class kelvin.api.client.model.responses.ResourceParametersListPaginatedResponseStream(**kwargs)

ResourceParametersListPaginatedResponseStream object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• comment (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• parameter_name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• source (KRN | None)

• updated (datetime | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• invalidated (datetime | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ParametersValuesGet(**kwargs)

ParametersValuesGet object.

Parameters:

• app_parameter_values (dict[str, dict[str, list[Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]]]] | None) – Optional[dict[str, dict[str, list[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]]]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

app_parameter_values: dict[str, dict[str, list[StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]]]] | None

class kelvin.api.client.model.responses.LegacyWorkloadDeploy(**kwargs)

LegacyWorkloadDeploy object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• networking (list[NetworkingItem] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• pre_download (Annotated[bool, Strict(strict=True)] | None)

• status (LegacyWorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• staged (LegacyWorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.Staged(**kwargs)

Staged object.

Parameters:

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (StagedStatus | None) – Optional[type_1.StagedStatus]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

ready: StrictBool | None

app_version: StrictStr | None

status: type_1.StagedStatus | None

class kelvin.api.client.model.responses.LegacyWorkloadItem(**kwargs)

LegacyWorkloadItem object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• download_status (WorkloadDownloadStatus | None) – Optional[enum.WorkloadDownloadStatus]

• download_error (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• pre_download (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• status (LegacyWorkloadStatus | None) – Optional[type_1.LegacyWorkloadStatus]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• staged (Staged | None) – Optional[Staged]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

acp_name: StrictStr | None

app_name: StrictStr | None

app_version: StrictStr | None

cluster_name: StrictStr | None

created: datetime | None

download_status: enum.WorkloadDownloadStatus | None

download_error: StrictStr | None

enabled: StrictBool | None

instantly_apply: StrictBool | None

name: StrictStr | None

node_name: StrictStr | None

pre_download: StrictBool | None

status: type_1.LegacyWorkloadStatus | None

title: StrictStr | None

updated: datetime | None

staged: Staged | None

class kelvin.api.client.model.responses.LegacyWorkloadsListPaginatedResponseCursor(**kwargs)

LegacyWorkloadsListPaginatedResponseCursor object.

Parameters:

• data (list[LegacyWorkloadItem] | None) – Optional[list[LegacyWorkloadItem]]

• pagination (PaginationCursor | None) – Optional[pagination_1.PaginationCursor]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[LegacyWorkloadItem] | None

pagination: PaginationCursor | None

class kelvin.api.client.model.responses.LegacyWorkloadsListPaginatedResponseLimits(**kwargs)

LegacyWorkloadsListPaginatedResponseLimits object.

Parameters:

• data (list[LegacyWorkloadItem] | None) – Optional[list[LegacyWorkloadItem]]

• pagination (PaginationLimits | None) – Optional[pagination_1.PaginationLimits]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

data: list[LegacyWorkloadItem] | None

pagination: PaginationLimits | None

class kelvin.api.client.model.responses.LegacyWorkloadsListPaginatedResponseStream(**kwargs)

LegacyWorkloadsListPaginatedResponseStream object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• instantly_apply (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• pre_download (Annotated[bool, Strict(strict=True)] | None)

• status (LegacyWorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• staged (Staged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyWorkloadConfigurationGet(**kwargs)

LegacyWorkloadConfigurationGet object.

Parameters:

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

configuration: dict[str, Any] | None

class kelvin.api.client.model.responses.LegacyWorkloadConfigurationUpdate(**kwargs)

LegacyWorkloadConfigurationUpdate object.

Parameters:

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

configuration: dict[str, Any] | None

class kelvin.api.client.model.responses.LegacyWorkloadDownload(**kwargs)

LegacyWorkloadDownload object.

Parameters:

• url (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• expires_in (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

url: StrictStr | None

expires_in: StrictInt | None

class kelvin.api.client.model.responses.LegacyWorkloadGet(**kwargs)

LegacyWorkloadGet object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• enabled (Annotated[bool, Strict(strict=True)] | None)

• name (Annotated[str, Strict(strict=True)] | None)

• networking (list[NetworkingItem] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• payload (dict[str, Any] | None)

• pre_download (Annotated[bool, Strict(strict=True)] | None)

• status (LegacyWorkloadStatus | None)

• title (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• staged (LegacyWorkloadStaged | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.LegacyWorkloadLogsGet(**kwargs)

LegacyWorkloadLogsGet object.

Parameters:

• logs (dict[str, list[Annotated[str, Strict(strict=True)]]] | None) – Optional[dict[str, list[StrictStr]]]

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

logs: dict[str, list[StrictStr]] | None

class kelvin.api.client.model.responses.ThreadCreate(**kwargs)

ThreadCreate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadsList(**kwargs)

ThreadsList object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadFollowUpdate(**kwargs)

ThreadFollowUpdate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadGet(**kwargs)

ThreadGet object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadReplyCreate(**kwargs)

ThreadReplyCreate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadReplyUpdate(**kwargs)

ThreadReplyUpdate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadSeenUpdate(**kwargs)

ThreadSeenUpdate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.responses.ThreadUpdate(**kwargs)

ThreadUpdate object.

Parameters:

• content (ThreadContent | None)

• created (datetime | None)

• follows (dict[str, ThreadUserFollow] | None)

• id (Annotated[str, Strict(strict=True)] | None)

• related_to (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)] | None)

• updated (datetime | None)

• user_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

Types

class kelvin.api.client.model.type.Created(**kwargs)

Created object.

Parameters:

• created_at (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• kwargs (Any)

created_at: datetime | None

created_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Updated(**kwargs)

Updated object.

Parameters:

• updated_at (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• kwargs (Any)

updated_at: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppVersion(**kwargs)

AppVersion object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• schemas (Schemas | None)

• defaults (Defaults | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Datastreams(**kwargs)

Datastreams object.

Parameters:

• map_to (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

map_to: StrictStr | None

configuration: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppDataQuality(**kwargs)

AppDataQuality object.

Parameters:

• way (DQWay | None) – Optional[enum.DQWay]

• datastreams (dict[str, dict[str, Any] | None] | None) – Optional[dict[str, Datastreams]]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

way: enum.DQWay | None

datastreams: dict[str, dict[str, Any] | None] | None

configuration: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DatastreamsModel(**kwargs)

DatastreamsModel object.

Parameters:

• map_to (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• remote (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• way (Way | None) – Optional[enum.Way]

• storage (Storage | None) – Optional[enum.Storage]

• dynamic_io_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

map_to: StrictStr | None

configuration: dict[str, Any] | None

remote: StrictBool | None

way: enum.Way | None

storage: enum.Storage | None

dynamic_io_type_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Resource(**kwargs)

Resource object.

Parameters:

• resource (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]

• datastreams (dict[str, DatastreamsModel] | None) – Optional[dict[str, DatastreamsModel]]

• data_quality (dict[str, AppDataQuality] | None) – Optional[dict[str, AppDataQuality]]

• kwargs (Any)

resource: StrictStr | None

parameters: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]] | None

datastreams: dict[str, DatastreamsModel] | None

data_quality: dict[str, AppDataQuality] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppDeploymentRuntimeResources(**kwargs)

AppDeploymentRuntimeResources object.

Parameters:

• resources (list[Resource] | None) – Optional[list[Resource]]

• kwargs (Any)

resources: list[Resource] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppDeploymentRuntime(**kwargs)

AppDeploymentRuntime object.

Parameters:

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• resources (list[Resource] | None)

• kwargs (Any)

configuration: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppResourceWorkload(**kwargs)

AppResourceWorkload object.

Parameters:

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• workload_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

app_version: StrictStr | None

workload_name: StrictStr | None

cluster_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppResource(**kwargs)

AppResource object.

Parameters:

• resource (KRN | None) – Optional[KRN]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• workloads (list[AppResourceWorkload] | None) – Optional[list[AppResourceWorkload]]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

resource: KRN | None

app_name: StrictStr | None

enabled: StrictBool | None

workloads: list[AppResourceWorkload] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppVersionOnly(**kwargs)

AppVersionOnly object.

Parameters:

• version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Deployment(**kwargs)

Deployment object.

Parameters:

• status (AppStatus | None) – Optional[enum.AppStatus]

• kwargs (Any)

status: enum.AppStatus | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.App(**kwargs)

App object.

Parameters:

• dashboard_uid (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• latest_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• versions (list[AppVersionOnly] | None) – Optional[list[AppVersionOnly]]

• deployment (Deployment | None) – Optional[Deployment]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• kwargs (Any)

dashboard_uid: StrictStr | None

latest_version: StrictStr | None

versions: list[AppVersionOnly] | None

deployment: Deployment | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppShort(**kwargs)

AppShort object.

Parameters:

• dashboard_uid (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• latest_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (AppStatus | None) – Optional[enum.AppStatus]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• kwargs (Any)

dashboard_uid: StrictStr | None

latest_version: StrictStr | None

status: enum.AppStatus | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppsResourceContext(**kwargs)

AppsResourceContext object.

Parameters:

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• kwargs (Any)

resource: KRN | None

source: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppVersionParameter(**kwargs)

AppVersionParameter object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• comment (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

app_name: StrictStr | None

app_version: StrictStr | None

comment: StrictStr | None

created: datetime | None

name: StrictStr | None

resource: KRN | None

value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppVersionHistoricParameter(**kwargs)

AppVersionHistoricParameter object.

Parameters:

• invalidated (datetime | None) – Optional[datetime]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• comment (Annotated[str, Strict(strict=True)] | None)

• created (datetime | None)

• name (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None)

• kwargs (Any)

invalidated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppParameter(**kwargs)

AppParameter object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type (ParameterType | None) – Optional[enum.ParameterType]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

app_name: StrictStr | None

title: StrictStr | None

name: StrictStr | None

data_type: enum.ParameterType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ParameterItemNoComment(**kwargs)

ParameterItemNoComment object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool]

• kwargs (Any)

name: StrictStr

value: StrictInt | StrictFloat | StrictStr | StrictBool

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ParameterItem(**kwargs)

ParameterItem object.

Parameters:

• comment (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)])

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)])

• kwargs (Any)

comment: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppVersionResourceParameters(**kwargs)

AppVersionResourceParameters object.

Parameters:

• resource (KRN) – KRN

• parameters (list[ParameterItem]) – list[ParameterItem]

• kwargs (Any)

resource: KRN

parameters: list[ParameterItem]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ParameterScheduleResourceParameter(**kwargs)

ParameterScheduleResourceParameter object.

Parameters:

• resource (KRN) – KRN

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]]) – dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool]]

• kwargs (Any)

resource: KRN

parameters: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Revert(**kwargs)

Revert object.

Parameters:

• scheduled_for (datetime) – datetime

• resource_parameters (list[ParameterScheduleResourceParameter]) – list[ParameterScheduleResourceParameter]

• kwargs (Any)

scheduled_for: datetime

resource_parameters: list[ParameterScheduleResourceParameter]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ParameterScheduleBase(**kwargs)

ParameterScheduleBase object.

Parameters:

• app_name (Annotated[str, Strict(strict=True)]) – StrictStr

• app_version (Annotated[str, Strict(strict=True)]) – StrictStr

• scheduled_for (datetime) – datetime

• resources (Annotated[list[KRN], MinLen(min_length=1)]) – list[KRN]

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]]) – dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool]]

• comment (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• revert (Revert | None) – Optional[Revert]

• kwargs (Any)

app_name: StrictStr

app_version: StrictStr

scheduled_for: datetime

resources: list[KRN]

parameters: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool]

comment: StrictStr | None

revert: Revert | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ParameterSchedule(**kwargs)

ParameterSchedule object.

Parameters:

• id (UUID) – UUID

• state (ParameterScheduleState) – enum.ParameterScheduleState

• original_resource_parameters (list[ParameterScheduleResourceParameter] | None) – Optional[list[ParameterScheduleResourceParameter]]

• error_msg (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created_at (datetime) – datetime

• created_by (KRN) – KRN

• applied_at (datetime | None) – Optional[datetime]

• applied_by (KRN | None) – Optional[KRN]

• reverted_at (datetime | None) – Optional[datetime]

• reverted_by (KRN | None) – Optional[KRN]

• app_name (Annotated[str, Strict(strict=True)])

• app_version (Annotated[str, Strict(strict=True)])

• scheduled_for (datetime)

• resources (Annotated[list[KRN], MinLen(min_length=1)])

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)]])

• comment (Annotated[str, Strict(strict=True)] | None)

• revert (Revert | None)

• kwargs (Any)

id: UUID

state: enum.ParameterScheduleState

original_resource_parameters: list[ParameterScheduleResourceParameter] | None

error_msg: StrictStr | None

created_at: datetime

created_by: KRN

applied_at: datetime | None

applied_by: KRN | None

reverted_at: datetime | None

reverted_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadStatus(**kwargs)

WorkloadStatus object.

Parameters:

• last_seen (datetime | None) – Optional[datetime]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (WorkloadStatus | None) – Optional[enum.WorkloadStatus]

• warnings (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

last_seen: datetime | None

message: StrictStr | None

state: enum.WorkloadStatus | None

warnings: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadCommon(**kwargs)

WorkloadCommon object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_type (AppType | None) – Optional[enum.AppType]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• download_status (WorkloadDownloadStatus | None) – Optional[enum.WorkloadDownloadStatus]

• download_error (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (WorkloadStatus | None) – Optional[WorkloadStatus]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

app_name: StrictStr | None

app_version: StrictStr | None

app_type: enum.AppType | None

cluster_name: StrictStr | None

node_name: StrictStr | None

download_status: enum.WorkloadDownloadStatus | None

download_error: StrictStr | None

status: WorkloadStatus | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadModifiableRuntimeResourceDatastream(**kwargs)

WorkloadModifiableRuntimeResourceDatastream object.

Parameters:

• map_to (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• way (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• storage (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• remote (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• dynamic_io_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

map_to: StrictStr | None

configuration: dict[str, Any] | None

way: StrictStr | None

storage: StrictStr | None

remote: StrictBool | None

dynamic_io_type_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailValue(**kwargs)

GuardrailValue object.

Parameters:

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)]) – Union[StrictInt, StrictFloat]

• inclusive (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

value: StrictInt | StrictFloat

inclusive: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailRelativeValue(**kwargs)

GuardrailRelativeValue object.

Parameters:

• value (Annotated[float, Strict(strict=True)]) – StrictFloat

• inclusive (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• type (GuardrailRelativeType | None) – Optional[enum.GuardrailRelativeType]

• kwargs (Any)

value: StrictFloat

inclusive: StrictBool | None

type: enum.GuardrailRelativeType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Increase(**kwargs)

Increase object.

Parameters:

• min (GuardrailRelativeValue | None) – Optional[GuardrailRelativeValue]

• max (GuardrailRelativeValue | None) – Optional[GuardrailRelativeValue]

• kwargs (Any)

min: GuardrailRelativeValue | None

max: GuardrailRelativeValue | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Decrease(**kwargs)

Decrease object.

Parameters:

• min (GuardrailRelativeValue | None) – Optional[GuardrailRelativeValue]

• max (GuardrailRelativeValue | None) – Optional[GuardrailRelativeValue]

• kwargs (Any)

min: GuardrailRelativeValue | None

max: GuardrailRelativeValue | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Relative(**kwargs)

Relative object.

Parameters:

• increase (Increase | None) – Optional[Increase]

• decrease (Decrease | None) – Optional[Decrease]

• kwargs (Any)

increase: Increase | None

decrease: Decrease | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailRelativeConfig(**kwargs)

GuardrailRelativeConfig object.

Parameters:

• relative (Relative | None) – Optional[Relative]

• kwargs (Any)

relative: Relative | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailNumberConfig(**kwargs)

GuardrailNumberConfig object.

Parameters:

• min (GuardrailValue | None) – Optional[GuardrailValue]

• max (GuardrailValue | None) – Optional[GuardrailValue]

• relative (Relative | None)

• kwargs (Any)

min: GuardrailValue | None

max: GuardrailValue | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Guardrail(**kwargs)

Guardrail object.

Parameters:

• control_disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• number (GuardrailNumberConfig | None) – Optional[GuardrailNumberConfig]

• kwargs (Any)

control_disabled: StrictBool | None

number: GuardrailNumberConfig | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DatastreamsModel1(**kwargs)

DatastreamsModel1 object.

Parameters:

• guardrail (Guardrail | None) – Optional[Guardrail]

• map_to (Annotated[str, Strict(strict=True)] | None)

• configuration (dict[str, Any] | None)

• way (Annotated[str, Strict(strict=True)] | None)

• storage (Annotated[str, Strict(strict=True)] | None)

• remote (Annotated[bool, Strict(strict=True)] | None)

• dynamic_io_type_name (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

guardrail: Guardrail | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ResourceModel(**kwargs)

ResourceModel object.

Parameters:

• resource (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• parameters (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]

• datastreams (dict[str, DatastreamsModel1] | None) – Optional[dict[str, DatastreamsModel1]]

• data_quality (dict[str, AppDataQuality] | None) – Optional[dict[str, AppDataQuality]]

• properties (dict[str, Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]]] | None) – Optional[dict[str, Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]]

• kwargs (Any)

resource: StrictStr | None

parameters: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]] | None

datastreams: dict[str, DatastreamsModel1] | None

data_quality: dict[str, AppDataQuality] | None

properties: dict[str, StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadRuntime(**kwargs)

WorkloadRuntime object.

Parameters:

• custom_actions (list[CustomAction] | None) – Optional[list[manifest.CustomAction]]

• resources (list[ResourceModel] | None) – Optional[list[ResourceModel]]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

custom_actions: list[manifest.CustomAction] | None

resources: list[ResourceModel] | None

configuration: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.StagedStatus(**kwargs)

StagedStatus object.

Parameters:

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (WorkloadStatus | None) – Optional[enum.WorkloadStatus]

• warnings (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

message: StrictStr | None

state: enum.WorkloadStatus | None

warnings: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadStaged(**kwargs)

WorkloadStaged object.

Parameters:

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• status (StagedStatus | None) – Optional[StagedStatus]

• runtime (WorkloadRuntime | None) – Optional[WorkloadRuntime]

• system (System | None) – Optional[manifest.System]

• kwargs (Any)

ready: StrictBool | None

app_version: StrictStr | None

deployment_type: enum.DeploymentType | None

status: StagedStatus | None

runtime: WorkloadRuntime | None

system: manifest.System | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Workload(**kwargs)

Workload object.

Parameters:

• runtime (WorkloadRuntime | None) – Optional[WorkloadRuntime]

• system (System | None) – Optional[manifest.System]

• staged (WorkloadStaged | None) – Optional[WorkloadStaged]

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• kwargs (Any)

runtime: WorkloadRuntime | None

system: manifest.System | None

staged: WorkloadStaged | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadStagedSummary(**kwargs)

WorkloadStagedSummary object.

Parameters:

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• status (StagedStatus | None) – Optional[StagedStatus]

• kwargs (Any)

ready: StrictBool | None

app_version: StrictStr | None

deployment_type: enum.DeploymentType | None

status: StagedStatus | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadSummary(**kwargs)

WorkloadSummary object.

Parameters:

• staged (WorkloadStagedSummary | None) – Optional[WorkloadStagedSummary]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• name (Annotated[str, Strict(strict=True)] | None)

• title (Annotated[str, Strict(strict=True)] | None)

• app_name (Annotated[str, Strict(strict=True)] | None)

• app_version (Annotated[str, Strict(strict=True)] | None)

• app_type (AppType | None)

• cluster_name (Annotated[str, Strict(strict=True)] | None)

• node_name (Annotated[str, Strict(strict=True)] | None)

• download_status (WorkloadDownloadStatus | None)

• download_error (Annotated[str, Strict(strict=True)] | None)

• status (WorkloadStatus | None)

• kwargs (Any)

staged: WorkloadStagedSummary | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.WorkloadNamesList(**kwargs)

WorkloadNamesList object.

Parameters:

• workload_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

workload_names: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AssetProperty(**kwargs)

AssetProperty object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | list[Annotated[int, Strict(strict=True)]] | list[Annotated[float, Strict(strict=True)]] | list[Annotated[str, Strict(strict=True)]] | list[Annotated[bool, Strict(strict=True)]] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, list[StrictInt], list[StrictFloat], list[StrictStr], list[StrictBool]]]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

value: StrictInt | StrictFloat | StrictStr | StrictBool | list[StrictInt] | list[StrictFloat] | list[StrictStr] | list[StrictBool] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AssetStatusItem(**kwargs)

AssetStatusItem object.

Parameters:

• last_seen (datetime | None) – Optional[datetime]

• state (AssetState | None) – Optional[enum.AssetState]

• kwargs (Any)

last_seen: datetime | None

state: enum.AssetState | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Asset(**kwargs)

Asset object.

Parameters:

• asset_type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• asset_type_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• properties (list[AssetProperty] | None) – Optional[list[AssetProperty]]

• in_use_by (list[KRN] | None) – Optional[list[KRN]]

• status (AssetStatusItem | None) – Optional[AssetStatusItem]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

asset_type_name: StrictStr | None

asset_type_title: StrictStr | None

created: datetime | None

name: StrictStr | None

properties: list[AssetProperty] | None

in_use_by: list[KRN] | None

status: AssetStatusItem | None

title: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.SimpleAsset(**kwargs)

SimpleAsset object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (AssetState | None) – Optional[enum.AssetState]

• kwargs (Any)

name: StrictStr | None

state: enum.AssetState | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AssetStatus(**kwargs)

AssetStatus object.

Parameters:

• data (list[SimpleAsset] | None) – Optional[list[SimpleAsset]]

• kwargs (Any)

data: list[SimpleAsset] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AssetType(**kwargs)

AssetType object.

Parameters:

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

name: StrictStr | None

title: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ControlChangeFrom(**kwargs)

ControlChangeFrom object.

Parameters:

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• timestamp (datetime) – datetime

• kwargs (Any)

value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

timestamp: datetime

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ControlChangeReport(**kwargs)

ControlChangeReport object.

Parameters:

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• timestamp (datetime) – datetime

• source (ControlChangeSource) – enum.ControlChangeSource

• kwargs (Any)

value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

timestamp: datetime

source: enum.ControlChangeSource

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ControlChangeReported(**kwargs)

ControlChangeReported object.

Parameters:

• before (ControlChangeReport | None) – Optional[ControlChangeReport]

• after (ControlChangeReport | None) – Optional[ControlChangeReport]

• kwargs (Any)

before: ControlChangeReport | None

after: ControlChangeReport | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionCreationFields(**kwargs)

CustomActionCreationFields object.

Parameters:

• type (Annotated[str, Strict(strict=True)]) – StrictStr

• type_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN) – KRN

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• expiration_date (datetime) – datetime

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

type: StrictStr

type_title: StrictStr | None

resource: KRN

title: StrictStr

description: StrictStr | None

expiration_date: datetime

payload: dict[str, Any] | None

trace_id: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionTransitionData(**kwargs)

CustomActionTransitionData object.

Parameters:

• state (CustomActionState) – enum.CustomActionState

• failure_reason (CustomActionFailureReason | None) – Optional[enum.CustomActionFailureReason]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

state: enum.CustomActionState

failure_reason: enum.CustomActionFailureReason | None

message: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.StatusLog(**kwargs)

StatusLog object.

Parameters:

• timestamp (datetime) – datetime

• source (Annotated[str, Strict(strict=True)]) – StrictStr

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

timestamp: datetime

source: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionTransitions(**kwargs)

CustomActionTransitions object.

Parameters:

• status_logs (list[StatusLog] | None) – Optional[list[StatusLog]]

• kwargs (Any)

status_logs: list[StatusLog] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomAction(**kwargs)

CustomAction object.

Parameters:

• id (UUID) – UUID

• timestamp (datetime | None) – Optional[datetime]

• created (datetime) – datetime

• created_by (KRN) – KRN

• updated (datetime) – datetime

• updated_by (KRN) – KRN

• status_logs (list[StatusLog] | None)

• state (CustomActionState)

• failure_reason (CustomActionFailureReason | None)

• message (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

id: UUID

timestamp: datetime | None

created: datetime

created_by: KRN

updated: datetime

updated_by: KRN

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionType(**kwargs)

CustomActionType object.

Parameters:

• created (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• kwargs (Any)

created: datetime | None

created_by: KRN | None

name: StrictStr | None

title: StrictStr | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinTimestampAnomaly(**kwargs)

KelvinTimestampAnomaly object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)]) – StrictBool

• kwargs (Any)

enabled: StrictBool

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Configuration(**kwargs)

Configuration object.

Parameters:

• window_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• window_interval_unit (WindowIntervalUnit | None) – Optional[enum.WindowIntervalUnit]

• kwargs (Any)

window_interval: StrictInt | None

window_interval_unit: enum.WindowIntervalUnit | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinStaleDetection(**kwargs)

KelvinStaleDetection object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)]) – StrictBool

• configuration (Configuration | None) – Optional[Configuration]

• kwargs (Any)

enabled: StrictBool

configuration: Configuration | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ConfigurationModel(**kwargs)

ConfigurationModel object.

Parameters:

• min_threshold (Annotated[float, Strict(strict=True)] | None) – Optional[StrictFloat]

• max_threshold (Annotated[float, Strict(strict=True)] | None) – Optional[StrictFloat]

• kwargs (Any)

min_threshold: StrictFloat | None

max_threshold: StrictFloat | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinOutOfRangeDetection(**kwargs)

KelvinOutOfRangeDetection object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)]) – StrictBool

• configuration (ConfigurationModel | None) – Optional[ConfigurationModel]

• kwargs (Any)

enabled: StrictBool

configuration: ConfigurationModel | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ZScore(**kwargs)

ZScore object.

Parameters:

• threshold (Annotated[float, Strict(strict=True)] | None) – Optional[StrictFloat]

• window_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

threshold: StrictFloat | None

window_size: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ConfigurationModel1(**kwargs)

ConfigurationModel1 object.

Parameters:

• model (OutlierDetectionModel | None) – Optional[enum.OutlierDetectionModel]

• z_score (ZScore | None) – Optional[ZScore]

• kwargs (Any)

model: enum.OutlierDetectionModel | None

z_score: ZScore | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinOutlierDetection(**kwargs)

KelvinOutlierDetection object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)]) – StrictBool

• configuration (ConfigurationModel1 | None) – Optional[ConfigurationModel1]

• kwargs (Any)

enabled: StrictBool

configuration: ConfigurationModel1 | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ConfigurationModel2(**kwargs)

ConfigurationModel2 object.

Parameters:

• window_expected_number_msgs (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• window_interval_unit (WindowIntervalUnit | None) – Optional[enum.WindowIntervalUnit]

• kwargs (Any)

window_expected_number_msgs: StrictInt | None

window_interval_unit: enum.WindowIntervalUnit | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinDataAvailability(**kwargs)

KelvinDataAvailability object.

Parameters:

• enabled (Annotated[bool, Strict(strict=True)]) – StrictBool

• configuration (ConfigurationModel2 | None) – Optional[ConfigurationModel2]

• kwargs (Any)

enabled: StrictBool

configuration: ConfigurationModel2 | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataQualityConfigurations(**kwargs)

DataQualityConfigurations object.

Parameters:

• kelvin_timestamp_anomaly (KelvinTimestampAnomaly | None) – Optional[KelvinTimestampAnomaly]

• kelvin_stale_detection (KelvinStaleDetection | None) – Optional[KelvinStaleDetection]

• kelvin_out_of_range_detection (KelvinOutOfRangeDetection | None) – Optional[KelvinOutOfRangeDetection]

• kelvin_outlier_detection (KelvinOutlierDetection | None) – Optional[KelvinOutlierDetection]

• kelvin_data_availability (KelvinDataAvailability | None) – Optional[KelvinDataAvailability]

• kwargs (Any)

kelvin_timestamp_anomaly: KelvinTimestampAnomaly | None

kelvin_stale_detection: KelvinStaleDetection | None

kelvin_out_of_range_detection: KelvinOutOfRangeDetection | None

kelvin_outlier_detection: KelvinOutlierDetection | None

kelvin_data_availability: KelvinDataAvailability | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataQualityCreationFields(**kwargs)

DataQualityCreationFields object.

Parameters:

• resource (KRN) – KRN

• configurations (DataQualityConfigurations) – DataQualityConfigurations

• kwargs (Any)

resource: KRN

configurations: DataQualityConfigurations

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Configurations(**kwargs)

Configurations object.

Parameters:

• kelvin_timestamp_anomaly (KelvinTimestampAnomaly | None) – Optional[KelvinTimestampAnomaly]

• kelvin_stale_detection (KelvinStaleDetection | None) – Optional[KelvinStaleDetection]

• kelvin_out_of_range_detection (KelvinOutOfRangeDetection | None) – Optional[KelvinOutOfRangeDetection]

• kelvin_outlier_detection (KelvinOutlierDetection | None) – Optional[KelvinOutlierDetection]

• kelvin_data_availability (KelvinDataAvailability | None) – Optional[KelvinDataAvailability]

• kwargs (Any)

kelvin_timestamp_anomaly: KelvinTimestampAnomaly | None

kelvin_stale_detection: KelvinStaleDetection | None

kelvin_out_of_range_detection: KelvinOutOfRangeDetection | None

kelvin_outlier_detection: KelvinOutlierDetection | None

kelvin_data_availability: KelvinDataAvailability | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataQuality(**kwargs)

DataQuality object.

Parameters:

• resource (KRN) – KRN

• configurations (Configurations) – Configurations

• created (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• kwargs (Any)

resource: KRN

configurations: Configurations

created: datetime | None

created_by: KRN | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.InUseByItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.type.DataQualityMetric(**kwargs)

DataQualityMetric object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type_name (DataType | None) – Optional[enum.DataType]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• is_protected (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• in_use_by (list[KRN] | None) – Optional[list[KRN]]

• created (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

data_type_name: enum.DataType | None

description: StrictStr | None

is_protected: StrictBool | None

in_use_by: list[KRN] | None

created: datetime | None

created_by: KRN | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.SimulationData(**kwargs)

SimulationData object.

Parameters:

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• resource (KRN | None) – Optional[KRN]

• timestamp (datetime | None) – Optional[datetime]

• kwargs (Any)

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

resource: KRN | None

timestamp: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.StatisticsData(**kwargs)

StatisticsData object.

Parameters:

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• timestamp (datetime | None) – Optional[datetime]

• kwargs (Any)

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

timestamp: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataStreamDataType(**kwargs)

DataStreamDataType object.

Parameters:

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

name: StrictStr | None

title: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataStreamSemanticType(**kwargs)

DataStreamSemanticType object.

Parameters:

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

name: StrictStr | None

title: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Unit(**kwargs)

Unit object.

Parameters:

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• symbol (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

name: StrictStr | None

symbol: StrictStr | None

title: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Context(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.type.DataTag(**kwargs)

DataTag object.

Parameters:

• id (UUID | None) – Optional[UUID]

• start_date (datetime | None) – Optional[datetime]

• end_date (datetime | None) – Optional[datetime]

• tag_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• contexts (list[KRN] | None) – Optional[list[KRN]]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

id: UUID | None

start_date: datetime | None

end_date: datetime | None

tag_name: StrictStr | None

resource: KRN | None

source: KRN | None

description: StrictStr | None

contexts: list[KRN] | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Tag(**kwargs)

Tag object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

metadata: dict[str, Any] | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Selector(**kwargs)

Selector object.

Parameters:

• resource (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• agg (TimeseriesAgg | None) – Optional[enum.TimeseriesAgg]

• time_bucket (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

resource: StrictStr | None

agg: enum.TimeseriesAgg | None

time_bucket: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ContextTimeSeries(**kwargs)

ContextTimeSeries object.

Parameters:

• start_time (datetime | None) – Optional[datetime]

• end_time (datetime | None) – Optional[datetime]

• selectors (list[Selector] | None) – Optional[list[Selector]]

• kwargs (Any)

start_time: datetime | None

end_time: datetime | None

selectors: list[Selector] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EventDetails(**kwargs)

EventDetails object.

Parameters:

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• severity (EventSeverity | None) – Optional[enum.EventSeverity]

• state (EventState | None) – Optional[enum.EventState]

• start_time (datetime | None) – Optional[datetime]

• end_time (datetime | None) – Optional[datetime]

• data_explorer_context (ContextTimeSeries | None) – Optional[ContextTimeSeries]

• kwargs (Any)

title: StrictStr | None

description: StrictStr | None

resource: KRN | None

severity: enum.EventSeverity | None

state: enum.EventState | None

start_time: datetime | None

end_time: datetime | None

data_explorer_context: ContextTimeSeries | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Event(**kwargs)

Event object.

Parameters:

• id (UUID | None) – Optional[UUID]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• title (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• resource (KRN | None)

• severity (EventSeverity | None)

• state (EventState | None)

• start_time (datetime | None)

• end_time (datetime | None)

• data_explorer_context (ContextTimeSeries | None)

• kwargs (Any)

id: UUID | None

trace_id: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.FileStorage(**kwargs)

FileStorage object.

Parameters:

• file_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• file_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• file_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• checksum (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• source (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

file_id: StrictStr | None

file_name: StrictStr | None

file_size: StrictInt | None

checksum: StrictStr | None

source: StrictStr | None

created: datetime | None

metadata: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailValueUpdater(**kwargs)

GuardrailValueUpdater object.

Parameters:

• source (KRN) – KRN

• inclusive (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

source: KRN

inclusive: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Number(**kwargs)

Number object.

Parameters:

• min (GuardrailValueUpdater | None) – Optional[GuardrailValueUpdater]

• max (GuardrailValueUpdater | None) – Optional[GuardrailValueUpdater]

• kwargs (Any)

min: GuardrailValueUpdater | None

max: GuardrailValueUpdater | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailUpdater(**kwargs)

GuardrailUpdater object.

Parameters:

• number (Number | None) – Optional[Number]

• kwargs (Any)

number: Number | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailConfig(**kwargs)

GuardrailConfig object.

Parameters:

• control_disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• number (GuardrailNumberConfig | None) – Optional[GuardrailNumberConfig]

• updater (GuardrailUpdater | None) – Optional[GuardrailUpdater]

• kwargs (Any)

control_disabled: StrictBool | None

number: GuardrailNumberConfig | None

updater: GuardrailUpdater | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailConfigWithResource(**kwargs)

GuardrailConfigWithResource object.

Parameters:

• resource (KRN) – KRN

• control_disabled (Annotated[bool, Strict(strict=True)] | None)

• number (GuardrailNumberConfig | None)

• updater (GuardrailUpdater | None)

• kwargs (Any)

resource: KRN

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Min(**kwargs)

Min object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)])

• inclusive (Annotated[bool, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Max(**kwargs)

Max object.

Parameters:

• updated_at (datetime | None)

• updated_by (KRN | None)

• value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)])

• inclusive (Annotated[bool, Strict(strict=True)] | None)

• kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailNumber(**kwargs)

GuardrailNumber object.

Parameters:

• min (Min | None) – Optional[Min]

• max (Max | None) – Optional[Max]

• relative (Relative | None)

• kwargs (Any)

min: Min | None

max: Max | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.GuardrailModel(**kwargs)

GuardrailModel object.

Parameters:

• resource (KRN) – KRN

• control_disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• number (GuardrailNumber | None) – Optional[GuardrailNumber]

• updater (GuardrailUpdater | None) – Optional[GuardrailUpdater]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

resource: KRN

control_disabled: StrictBool | None

number: GuardrailNumber | None

updater: GuardrailUpdater | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.InstanceAuditLogItem(**kwargs)

InstanceAuditLogItem object.

Parameters:

• action (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• id (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• identifier (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• meta (dict[str, Any] | None) – Optional[dict[str, Any]]

• namespace (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• request_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• user_id (UUID | None) – Optional[UUID]

• username (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

action: StrictStr | None

created: datetime | None

id: StrictInt | None

identifier: StrictStr | None

meta: dict[str, Any] | None

namespace: StrictStr | None

request_id: StrictStr | None

user_id: UUID | None

username: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.InstanceSettings(**kwargs)

InstanceSettings object.

Parameters:

• created (datetime | None) – Optional[datetime]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

name: StrictStr | None

payload: dict[str, Any] | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeUi(**kwargs)

EdgeUi object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeCcm(**kwargs)

EdgeCcm object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeK8s(**kwargs)

EdgeK8s object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeInfo(**kwargs)

EdgeInfo object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeMqtt(**kwargs)

EdgeMqtt object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• expose (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• anonymous (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

expose: StrictBool | None

anonymous: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeNats(**kwargs)

EdgeNats object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeSync(**kwargs)

EdgeSync object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeLeaderApi(**kwargs)

EdgeLeaderApi object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.EdgeCustomActionManager(**kwargs)

EdgeCustomActionManager object.

Parameters:

• disabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

disabled: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ClusterEdgeApps(**kwargs)

ClusterEdgeApps object.

Parameters:

• edge_ui (EdgeUi | None) – Optional[EdgeUi]

• edge_ccm (EdgeCcm | None) – Optional[EdgeCcm]

• edge_k8s (EdgeK8s | None) – Optional[EdgeK8s]

• edge_info (EdgeInfo | None) – Optional[EdgeInfo]

• edge_mqtt (EdgeMqtt | None) – Optional[EdgeMqtt]

• edge_nats (EdgeNats | None) – Optional[EdgeNats]

• edge_sync (EdgeSync | None) – Optional[EdgeSync]

• edge_leader_api (EdgeLeaderApi | None) – Optional[EdgeLeaderApi]

• edge_custom_action_manager (EdgeCustomActionManager | None) – Optional[EdgeCustomActionManager]

• kwargs (Any)

edge_ui: EdgeUi | None

edge_ccm: EdgeCcm | None

edge_k8s: EdgeK8s | None

edge_info: EdgeInfo | None

edge_mqtt: EdgeMqtt | None

edge_nats: EdgeNats | None

edge_sync: EdgeSync | None

edge_leader_api: EdgeLeaderApi | None

edge_custom_action_manager: EdgeCustomActionManager | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ClusterEdgeOptions(**kwargs)

ClusterEdgeOptions object.

Parameters:

• image_pull_policy (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

image_pull_policy: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.UpgradeStatus(**kwargs)

UpgradeStatus object.

Parameters:

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (UpgradeStatusState | None) – Optional[enum.UpgradeStatusState]

• kwargs (Any)

message: StrictStr | None

state: enum.UpgradeStatusState | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Version(**kwargs)

Version object.

Parameters:

• k8s_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kelvin_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

k8s_version: StrictStr | None

kelvin_version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.OrchestrationCluster(**kwargs)

OrchestrationCluster object.

Parameters:

• created (datetime | None) – Optional[datetime]

• forward_logs_buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• forward_logs_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• join_script (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• download_provision_script (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ha_mode (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• ha_mode_warning (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• last_seen (datetime | None) – Optional[datetime]

• manifests_scrape_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• manifests_scrape_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• provision_script (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• service_account_token (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• status (OrchestrationClusterStatus | None) – Optional[enum.OrchestrationClusterStatus]

• sync_scrape_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• telemetry_buffer_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• telemetry_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• telemetry_scrape_interval (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• telemetry_alerts_enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (ClusterType | None) – Optional[enum.ClusterType]

• updated (datetime | None) – Optional[datetime]

• upgrade_instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• upgrade_pre_download (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• upgrade_status (UpgradeStatus | None) – Optional[UpgradeStatus]

• version (Version | None) – Optional[Version]

• edge_apps (ClusterEdgeApps | None) – Optional[ClusterEdgeApps]

• edge_options (ClusterEdgeOptions | None) – Optional[ClusterEdgeOptions]

• kwargs (Any)

created: datetime | None

forward_logs_buffer_size: StrictInt | None

forward_logs_enabled: StrictBool | None

join_script: StrictStr | None

download_provision_script: StrictStr | None

ha_mode: StrictBool | None

ha_mode_warning: StrictStr | None

last_seen: datetime | None

manifests_scrape_enabled: StrictBool | None

manifests_scrape_interval: StrictInt | None

name: StrictStr | None

provision_script: StrictStr | None

ready: StrictBool | None

service_account_token: StrictStr | None

status: enum.OrchestrationClusterStatus | None

sync_scrape_interval: StrictInt | None

telemetry_buffer_size: StrictInt | None

telemetry_enabled: StrictBool | None

telemetry_scrape_interval: StrictInt | None

telemetry_alerts_enabled: StrictBool | None

title: StrictStr | None

type: enum.ClusterType | None

updated: datetime | None

upgrade_instantly_apply: StrictBool | None

upgrade_pre_download: StrictBool | None

upgrade_status: UpgradeStatus | None

version: Version | None

edge_apps: ClusterEdgeApps | None

edge_options: ClusterEdgeOptions | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.NodeCapacity(**kwargs)

NodeCapacity object.

Parameters:

• cpu (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• ephemeral_storage (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• memory (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• pods (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

cpu: StrictStr | None

ephemeral_storage: StrictStr | None

memory: StrictStr | None

pods: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.PropertyDefinition(**kwargs)

PropertyDefinition object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• primitive_type (PropertyType | None) – Optional[enum.PropertyType]

• created (datetime | None) – Optional[datetime]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

primitive_type: enum.PropertyType | None

created: datetime | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.PropertyValueHistory(**kwargs)

PropertyValueHistory object.

Parameters:

• property_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resource (KRN | None) – Optional[KRN]

• timestamp (datetime | None) – Optional[datetime]

• source (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• value (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

property_name: StrictStr | None

resource: KRN | None

timestamp: datetime | None

source: StrictStr | None

value: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationEvidence(**kwargs)

RecommendationEvidence object.

Parameters:

• type (RecommendationEvidenceType | None) – Optional[enum.RecommendationEvidenceType]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

type: enum.RecommendationEvidenceType | None

payload: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationBase(**kwargs)

RecommendationBase object.

Parameters:

• confidence (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• custom_identifier (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• expiration_date (datetime | None) – Optional[datetime]

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• resource (KRN) – KRN

• resource_parameters (dict[str, Any] | None) – Optional[dict[str, Any]]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (Annotated[str, Strict(strict=True)]) – StrictStr

• evidences (list[RecommendationEvidence] | None) – Optional[list[RecommendationEvidence]]

• kwargs (Any)

confidence: StrictInt | None

custom_identifier: StrictStr | None

description: StrictStr | None

expiration_date: datetime | None

metadata: dict[str, Any] | None

resource: KRN

resource_parameters: dict[str, Any] | None

trace_id: StrictStr | None

type: StrictStr

evidences: list[RecommendationEvidence] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationControlChangeCreate(**kwargs)

RecommendationControlChangeCreate object.

Parameters:

• control_change_id (UUID | None) – Optional[UUID]

• expiration_date (datetime) – datetime

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• resource (KRN) – KRN

• retries (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• timeout (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• from – Optional[ControlChangeFrom]

• from_ (ControlChangeFrom | None)

• kwargs (Any)

control_change_id: UUID | None

expiration_date: datetime

trace_id: StrictStr | None

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

resource: KRN

retries: StrictInt | None

timeout: StrictInt | None

from_: ControlChangeFrom | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionModel(**kwargs)

CustomActionModel object.

Parameters:

• custom_action_id (UUID | None) – Optional[UUID]

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

custom_action_id: UUID | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationActionsCreate(**kwargs)

RecommendationActionsCreate object.

Parameters:

• control_changes (list[RecommendationControlChangeCreate] | None) – Optional[list[RecommendationControlChangeCreate]]

• custom_actions (list[CustomActionModel] | None) – Optional[list[CustomActionModel]]

• kwargs (Any)

control_changes: list[RecommendationControlChangeCreate] | None

custom_actions: list[CustomActionModel] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationControlChange(**kwargs)

RecommendationControlChange object.

Parameters:

• control_change_id (UUID | None) – Optional[UUID]

• trace_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• expiration_date (datetime | None) – Optional[datetime]

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• resource (KRN) – KRN

• retries (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• timeout (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• from – Optional[ControlChangeFrom]

• status (RecommendationActionStatus | None) – Optional[enum.RecommendationActionStatus]

• status_message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• from_ (ControlChangeFrom | None)

• kwargs (Any)

control_change_id: UUID | None

trace_id: StrictStr | None

expiration_date: datetime | None

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

resource: KRN

retries: StrictInt | None

timeout: StrictInt | None

from_: ControlChangeFrom | None

status: enum.RecommendationActionStatus | None

status_message: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActionModel1(**kwargs)

CustomActionModel1 object.

Parameters:

• custom_action_id (UUID | None) – Optional[UUID]

• status (RecommendationActionStatus | None) – Optional[enum.RecommendationActionStatus]

• status_message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (Annotated[str, Strict(strict=True)])

• type_title (Annotated[str, Strict(strict=True)] | None)

• resource (KRN)

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime)

• payload (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• kwargs (Any)

custom_action_id: UUID | None

status: enum.RecommendationActionStatus | None

status_message: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationActions(**kwargs)

RecommendationActions object.

Parameters:

• control_changes (list[RecommendationControlChange] | None) – Optional[list[RecommendationControlChange]]

• custom_actions (list[CustomActionModel1] | None) – Optional[list[CustomActionModel1]]

• kwargs (Any)

control_changes: list[RecommendationControlChange] | None

custom_actions: list[CustomActionModel1] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Recommendation(**kwargs)

Recommendation object.

Parameters:

• actions (RecommendationActions | None) – Optional[RecommendationActions]

• id (UUID | None) – Optional[UUID]

• type_title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (RecommendationState | None) – Optional[enum.RecommendationState]

• created (datetime | None) – Optional[datetime]

• source (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• confidence (Annotated[int, Strict(strict=True)] | None)

• custom_identifier (Annotated[str, Strict(strict=True)] | None)

• description (Annotated[str, Strict(strict=True)] | None)

• expiration_date (datetime | None)

• metadata (dict[str, Any] | None)

• resource (KRN)

• resource_parameters (dict[str, Any] | None)

• trace_id (Annotated[str, Strict(strict=True)] | None)

• type (Annotated[str, Strict(strict=True)])

• evidences (list[RecommendationEvidence] | None)

• kwargs (Any)

actions: RecommendationActions | None

id: UUID | None

type_title: StrictStr | None

message: StrictStr | None

state: enum.RecommendationState | None

created: datetime | None

source: KRN | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RecommendationType(**kwargs)

RecommendationType object.

Parameters:

• created (datetime | None) – Optional[datetime]

• created_by (KRN | None) – Optional[KRN]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• metadata (dict[str, Any] | None) – Optional[dict[str, Any]]

• updated (datetime | None) – Optional[datetime]

• updated_by (KRN | None) – Optional[KRN]

• kwargs (Any)

created: datetime | None

created_by: KRN | None

name: StrictStr | None

title: StrictStr | None

metadata: dict[str, Any] | None

updated: datetime | None

updated_by: KRN | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ThreadAttachment(**kwargs)

ThreadAttachment object.

Parameters:

• extension (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• filename (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• url (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

extension: StrictStr | None

filename: StrictStr | None

size: StrictInt | None

url: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ThreadUserFollow(**kwargs)

ThreadUserFollow object.

Parameters:

• mute (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• seen (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

mute: StrictBool | None

seen: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.KelvinMessage(**kwargs)

KelvinMessage object.

Parameters:

• id (UUID) – UUID

• type (Annotated[str, Strict(strict=True)]) – StrictStr

• resource (KRN) – KRN

• source (KRN) – KRN

• timestamp (datetime) – datetime

• payload (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]) – Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]

• kwargs (Any)

id: UUID

type: StrictStr

resource: KRN

source: KRN

timestamp: datetime

payload: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.TimeseriesData(**kwargs)

TimeseriesData object.

Parameters:

• created (datetime | None) – Optional[datetime]

• data_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• fields (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• last_timestamp (datetime | None) – Optional[datetime]

• last_value (Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any] | None) – Optional[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]

• resource (KRN | None) – Optional[KRN]

• source (KRN | None) – Optional[KRN]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

data_type: StrictStr | None

fields: list[StrictStr] | None

last_timestamp: datetime | None

last_value: StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any] | None

resource: KRN | None

source: KRN | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.UserSetting(**kwargs)

UserSetting object.

Parameters:

• created (datetime | None) – Optional[datetime]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• setting_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• kwargs (Any)

created: datetime | None

payload: dict[str, Any] | None

setting_name: StrictStr | None

updated: datetime | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.SharedSetting(**kwargs)

SharedSetting object.

Parameters:

• created (datetime | None) – Optional[datetime]

• created_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• setting_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• updated_by (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

created: datetime | None

created_by: StrictStr | None

payload: dict[str, Any] | None

setting_name: StrictStr | None

updated: datetime | None

updated_by: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.TaskResourceListItem(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.type.TaskUIMetadata(**kwargs)

TaskUIMetadata object.

Parameters:

kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Parameters(**kwargs)

Parameters object.

Parameters:

• kelvin_closed_loop (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

kelvin_closed_loop: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DatastreamsModel2(**kwargs)

DatastreamsModel2 object.

Parameters:

• way (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

way: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.DataTags(**kwargs)

DataTags object.

Parameters:

• way (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

way: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.CustomActions(**kwargs)

CustomActions object.

Parameters:

• way (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

way: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.TaskDefinition(**kwargs)

TaskDefinition object.

Parameters:

• parameters (Parameters | None) – Optional[Parameters]

• datastreams (dict[str, DatastreamsModel2] | None) – Optional[dict[str, DatastreamsModel2]]

• data_tags (dict[str, DataTags] | None) – Optional[dict[str, DataTags]]

• custom_actions (dict[str, CustomActions] | None) – Optional[dict[str, CustomActions]]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

parameters: Parameters | None

datastreams: dict[str, DatastreamsModel2] | None

data_tags: dict[str, DataTags] | None

custom_actions: dict[str, CustomActions] | None

configuration: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Task(**kwargs)

Task object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• resources (list[TaskResourceListItem] | None) – Optional[list[TaskResourceListItem]]

• definition (TaskDefinition | None) – Optional[TaskDefinition]

• ui_metadata (TaskUIMetadata | None) – Optional[TaskUIMetadata]

• updated_at (datetime | None)

• updated_by (KRN | None)

• created_at (datetime | None)

• created_by (KRN | None)

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

resources: list[TaskResourceListItem] | None

definition: TaskDefinition | None

ui_metadata: TaskUIMetadata | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RolePolicyActions(root)

Parameters:

root (list[P])

root: list[enum.RolePolicyAction]

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.type.RoleConditionExpr(**kwargs)

RoleConditionExpr object.

Parameters:

• expr (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

expr: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RoleConditionExprList(**kwargs)

RoleConditionExprList object.

Parameters:

• of (Annotated[list[RoleConditionExpr], MinLen(min_length=1)]) – list[RoleConditionExpr]

• kwargs (Any)

of: list[RoleConditionExpr]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Match(**kwargs)

Match object.

Parameters:

all (RoleConditionExprList) – RoleConditionExprList

model_config = {'extra': 'forbid', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

all: RoleConditionExprList

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.MatchModel(**kwargs)

MatchModel object.

Parameters:

any (RoleConditionExprList) – RoleConditionExprList

model_config = {'extra': 'forbid', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

any: RoleConditionExprList

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.RolePolicyCondition(**kwargs)

RolePolicyCondition object.

Parameters:

• match (RoleConditionExpr | Match | MatchModel) – Union[RoleConditionExpr, Match, MatchModel]

• kwargs (Any)

match: RoleConditionExpr | Match | MatchModel

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.LegacyAppVersion(**kwargs)

LegacyAppVersion object.

Parameters:

• created (datetime | None) – Optional[datetime]

• id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• updated (datetime | None) – Optional[datetime]

• version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

created: datetime | None

id: StrictStr | None

payload: dict[str, Any] | None

updated: datetime | None

version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.LegacyApp(**kwargs)

LegacyApp object.

Parameters:

• created (datetime | None) – Optional[datetime]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• latest_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (LegacyAppType | None) – Optional[enum.LegacyAppType]

• updated (datetime | None) – Optional[datetime]

• versions (list[LegacyAppVersion] | None) – Optional[list[LegacyAppVersion]]

• kwargs (Any)

created: datetime | None

description: StrictStr | None

latest_version: StrictStr | None

name: StrictStr | None

title: StrictStr | None

type: enum.LegacyAppType | None

updated: datetime | None

versions: list[LegacyAppVersion] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.AppYaml(**kwargs)

AppYaml object.

Parameters:

kwargs (Any)

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Bridge(**kwargs)

Bridge object.

Parameters:

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (AppYaml | None) – Optional[AppYaml]

• status (WorkloadStatus | None) – Optional[WorkloadStatus]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• workload_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

cluster_name: StrictStr | None

created: datetime | None

enabled: StrictBool | None

name: StrictStr | None

node_name: StrictStr | None

payload: AppYaml | None

status: WorkloadStatus | None

title: StrictStr | None

updated: datetime | None

workload_name: StrictStr | None

app_name: StrictStr | None

app_version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ResourceParameters(**kwargs)

ResourceParameters object.

Parameters:

• resource (KRN) – KRN

• parameters (list[ParameterItem]) – list[ParameterItem]

• kwargs (Any)

resource: KRN

parameters: list[ParameterItem]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.NetworkingAddressItem(**kwargs)

NetworkingAddressItem object.

Parameters:

• address (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• interface (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• port (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

address: StrictStr | None

interface: StrictStr | None

port: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.NetworkingItem(**kwargs)

NetworkingItem object.

Parameters:

• addresses (list[NetworkingAddressItem] | None) – Optional[list[NetworkingAddressItem]]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• protocol (Protocol | None) – Optional[enum.Protocol]

• kwargs (Any)

addresses: list[NetworkingAddressItem] | None

name: StrictStr | None

protocol: enum.Protocol | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.LegacyWorkloadStatus(**kwargs)

LegacyWorkloadStatus object.

Parameters:

• last_seen (datetime | None) – Optional[datetime]

• message (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• state (WorkloadStatus | None) – Optional[enum.WorkloadStatus]

• warnings (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

last_seen: datetime | None

message: StrictStr | None

state: enum.WorkloadStatus | None

warnings: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.LegacyWorkloadStaged(**kwargs)

LegacyWorkloadStaged object.

Parameters:

• ready (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• instantly_apply (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• status (StagedStatus | None) – Optional[StagedStatus]

• kwargs (Any)

ready: StrictBool | None

app_version: StrictStr | None

payload: dict[str, Any] | None

instantly_apply: StrictBool | None

status: StagedStatus | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.LegacyWorkload(**kwargs)

LegacyWorkload object.

Parameters:

• acp_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• app_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• cluster_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• created (datetime | None) – Optional[datetime]

• download_status (WorkloadDownloadStatus | None) – Optional[enum.WorkloadDownloadStatus]

• download_error (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• enabled (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• networking (list[NetworkingItem] | None) – Optional[list[NetworkingItem]]

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | None) – Optional[dict[str, Any]]

• pre_download (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• status (LegacyWorkloadStatus | None) – Optional[LegacyWorkloadStatus]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• staged (LegacyWorkloadStaged | None) – Optional[LegacyWorkloadStaged]

• kwargs (Any)

acp_name: StrictStr | None

app_name: StrictStr | None

app_version: StrictStr | None

cluster_name: StrictStr | None

created: datetime | None

download_status: enum.WorkloadDownloadStatus | None

download_error: StrictStr | None

enabled: StrictBool | None

name: StrictStr | None

networking: list[NetworkingItem] | None

node_name: StrictStr | None

payload: dict[str, Any] | None

pre_download: StrictBool | None

status: LegacyWorkloadStatus | None

title: StrictStr | None

updated: datetime | None

staged: LegacyWorkloadStaged | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ThreadContent(**kwargs)

ThreadContent object.

Parameters:

• attachments (list[ThreadAttachment] | None) – Optional[list[ThreadAttachment]]

• mentions (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• replies (list[ThreadReply] | None) – Optional[list[ThreadReply]]

• text (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

attachments: list[ThreadAttachment] | None

mentions: list[StrictStr] | None

replies: list[ThreadReply] | None

text: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.ThreadReply(**kwargs)

ThreadReply object.

Parameters:

• content (ThreadContent | None) – Optional[ThreadContent]

• created (datetime | None) – Optional[datetime]

• id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• user_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

content: ThreadContent | None

created: datetime | None

id: StrictStr | None

updated: datetime | None

user_id: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.type.Thread(**kwargs)

Thread object.

Parameters:

• content (ThreadContent | None) – Optional[ThreadContent]

• created (datetime | None) – Optional[datetime]

• follows (dict[str, ThreadUserFollow] | None) – Optional[dict[str, ThreadUserFollow]]

• id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• related_to (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• updated (datetime | None) – Optional[datetime]

• user_id (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

content: ThreadContent | None

created: datetime | None

follows: dict[str, ThreadUserFollow] | None

id: StrictStr | None

related_to: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

type: StrictStr | None

updated: datetime | None

user_id: StrictStr | None

Enums

class kelvin.api.client.model.enum.AppType(*values)

app = 'app'

importer = 'importer'

exporter = 'exporter'

docker = 'docker'

task = 'task'

class kelvin.api.client.model.enum.GatewayMode(*values)

socket = 'socket'

legacy = 'legacy'

class kelvin.api.client.model.enum.Way(*values)

output = 'output'

input_cc = 'input-cc'

input_cc_output = 'input-cc+output'

input = 'input'

output_cc = 'output-cc'

input_output_cc = 'input+output-cc'

class kelvin.api.client.model.enum.Storage(*values)

node_and_cloud = 'node-and-cloud'

node = 'node'

none = 'none'

class kelvin.api.client.model.enum.DynamicIOOwnership(*values)

both = 'both'

owned = 'owned'

remote = 'remote'

class kelvin.api.client.model.enum.DynamicIOType(*values)

both = 'both'

data = 'data'

control = 'control'

class kelvin.api.client.model.enum.ParameterDataType(*values)

string = 'string'

number = 'number'

boolean = 'boolean'

class kelvin.api.client.model.enum.CAWay(*values)

input_ca = 'input-ca'

output_ca = 'output-ca'

class kelvin.api.client.model.enum.DQWay(*values)

output = 'output'

input = 'input'

class kelvin.api.client.model.enum.DeploymentType(*values)

standard = 'standard'

staged_instant_apply = 'staged+instant-apply'

staged_only = 'staged-only'

class kelvin.api.client.model.enum.DeploymentTargetType(*values)

cluster = 'cluster'

resource_cluster = 'resource-cluster'

class kelvin.api.client.model.enum.LivenessProbeType(*values)

http_get = 'http_get'

tcp_socket = 'tcp_socket'

exec = 'exec'

class kelvin.api.client.model.enum.URIScheme(*values)

http = 'http'

https = 'https'

class kelvin.api.client.model.enum.PortType(*values)

host = 'host'

service = 'service'

class kelvin.api.client.model.enum.VolumeType(*values)

persistent = 'persistent'

host = 'host'

text = 'text'

class kelvin.api.client.model.enum.VolumeEncoding(*values)

utf_8 = 'utf-8'

ascii = 'ascii'

latin_1 = 'latin_1'

class kelvin.api.client.model.enum.AppStatus(*values)

running = 'running'

stopped = 'stopped'

updating = 'updating'

requires_attention = 'requires_attention'

class kelvin.api.client.model.enum.ParameterType(*values)

number = 'number'

string = 'string'

boolean = 'boolean'

class kelvin.api.client.model.enum.ParameterScheduleState(*values)

scheduled = 'scheduled'

scheduled_revert = 'scheduled-revert'

completed = 'completed'

error = 'error'

class kelvin.api.client.model.enum.ParameterScheduleApplyType(*values)

schedule = 'schedule'

schedule_revert = 'schedule-revert'

class kelvin.api.client.model.enum.WorkloadDownloadStatus(*values)

pending = 'pending'

scheduled = 'scheduled'

processing = 'processing'

downloading = 'downloading'

ready = 'ready'

failed = 'failed'

class kelvin.api.client.model.enum.WorkloadStatus(*values)

pending_deploy = 'pending_deploy'

pending_update = 'pending_update'

pending_start = 'pending_start'

pending_stop = 'pending_stop'

pending_apply = 'pending_apply'

deploying = 'deploying'

running = 'running'

stopping = 'stopping'

stopped = 'stopped'

failed = 'failed'

starting = 'starting'

applying = 'applying'

received = 'received'

downloading = 'downloading'

ready = 'ready'

unreachable = 'unreachable'

staged = 'staged'

class kelvin.api.client.model.enum.GuardrailRelativeType(*values)

VALUE = 'value'

PERCENTAGE = 'percentage'

class kelvin.api.client.model.enum.AssetState(*values)

online = 'online'

offline = 'offline'

unknown = 'unknown'

class kelvin.api.client.model.enum.AssetInsightsOperator(*values)

Equal = '=='

NotEqual = '!='

Lower = '<'

Greater = '>'

GreaterOrEqual = '>='

LowerOrEqual = '<='

Has = 'has'

NotHas = '!has'

Contains = 'contains'

NotContains = '!contains'

StartsWith = 'starts_with'

NotStartsWith = '!starts_with'

EndsWith = 'ends_with'

NotEndsWith = '!ends_with'

class kelvin.api.client.model.enum.PropertyType(*values)

boolean = 'boolean'

number = 'number'

string = 'string'

timestamp = 'timestamp'

list_boolean_ = 'list[boolean]'

list_number_ = 'list[number]'

list_string_ = 'list[string]'

list_timestamp_ = 'list[timestamp]'

class kelvin.api.client.model.enum.ControlChangeState(*values)

pending = 'pending'

ready = 'ready'

sent = 'sent'

processed = 'processed'

applied = 'applied'

failed = 'failed'

rejected = 'rejected'

class kelvin.api.client.model.enum.CustomActionState(*values)

pending = 'pending'

ready = 'ready'

in_progress = 'in_progress'

completed = 'completed'

cancelled = 'cancelled'

failed = 'failed'

class kelvin.api.client.model.enum.AssetInsightsAgg(*values)

count = 'count'

mean = 'mean'

sum = 'sum'

max = 'max'

min = 'min'

class kelvin.api.client.model.enum.RecommendationState(*values)

pending = 'pending'

accepted = 'accepted'

auto_accepted = 'auto_accepted'

rejected = 'rejected'

expired = 'expired'

class kelvin.api.client.model.enum.AssetInsightsParameterScheduleType(*values)

permanent = 'permanent'

temporary = 'temporary'

class kelvin.api.client.model.enum.ControlChangeFilterField(*values)

timestamp = 'timestamp'

last_state = 'last_state'

datastream_name = 'datastream_name'

class kelvin.api.client.model.enum.RecommendationFilterField(*values)

created = 'created'

updated = 'updated'

type_name = 'type_name'

state = 'state'

class kelvin.api.client.model.enum.DataTagFilterField(*values)

tag = 'tag'

source = 'source'

end_date = 'end_date'

class kelvin.api.client.model.enum.AssetInsightsSortByDirection(*values)

asc = 'asc'

desc = 'desc'

class kelvin.api.client.model.enum.AssetInsightsState(*values)

online = 'online'

offline = 'offline'

unknown = 'unknown'

class kelvin.api.client.model.enum.ControlChangeSource(*values)

bridge = 'bridge'

ccm = 'ccm'

class kelvin.api.client.model.enum.CustomActionFailureReason(*values)

none = 'none'

other = 'other'

reported_failed = 'reported_failed'

expired = 'expired'

lost = 'lost'

executor_gone = 'executor_gone'

class kelvin.api.client.model.enum.WindowIntervalUnit(*values)

sec = 'sec'

min = 'min'

hour = 'hour'

day = 'day'

class kelvin.api.client.model.enum.OutlierDetectionModel(*values)

z_score = 'z_score'

class kelvin.api.client.model.enum.DataType(*values)

boolean = 'boolean'

number = 'number'

object = 'object'

string = 'string'

class kelvin.api.client.model.enum.DataStreamType(*values)

computed = 'computed'

measurement = 'measurement'

set_point = 'set_point'

class kelvin.api.client.model.enum.EventSeverity(*values)

low = 'low'

medium = 'medium'

high = 'high'

critical = 'critical'

class kelvin.api.client.model.enum.EventState(*values)

pending = 'pending'

accepted = 'accepted'

rejected = 'rejected'

class kelvin.api.client.model.enum.TimeseriesAgg(*values)

none = 'none'

count = 'count'

distinct = 'distinct'

integral = 'integral'

mean = 'mean'

median = 'median'

mode = 'mode'

spread = 'spread'

stddev = 'stddev'

sum = 'sum'

max = 'max'

min = 'min'

first = 'first'

last = 'last'

class kelvin.api.client.model.enum.ClusterType(*values)

k3s = 'k3s'

kubernetes = 'kubernetes'

docker = 'docker'

class kelvin.api.client.model.enum.OrchestrationClusterStatus(*values)

pending_provision = 'pending_provision'

pending = 'pending'

online = 'online'

unreachable = 'unreachable'

requires_attention = 'requires_attention'

class kelvin.api.client.model.enum.UpgradeStatusState(*values)

idle = 'idle'

downloading = 'downloading'

ready = 'ready'

class kelvin.api.client.model.enum.OrchestrationNodeStatus(*values)

online = 'online'

unreachable = 'unreachable'

not_ready = 'not_ready'

class kelvin.api.client.model.enum.ServiceType(*values)

cluster_ip = 'cluster_ip'

node_port = 'node_port'

host_port = 'host_port'

class kelvin.api.client.model.enum.RecommendationEvidenceType(*values)

markdown = 'markdown'

image = 'image'

iframe = 'iframe'

chart = 'chart'

line_chart = 'line-chart'

bar_chart = 'bar-chart'

dynacard = 'dynacard'

data_explorer = 'data-explorer'

class kelvin.api.client.model.enum.RecommendationStateCreate(*values)

pending = 'pending'

auto_accepted = 'auto_accepted'

class kelvin.api.client.model.enum.RecommendationActionStatus(*values)

none = 'none'

dispatched = 'dispatched'

dispatch_error = 'dispatch_error'

class kelvin.api.client.model.enum.TimeseriesOrder(*values)

ASC = 'ASC'

DESC = 'DESC'

class kelvin.api.client.model.enum.ResourceType(*values)

asset = 'asset'

datastream = 'datastream'

app = 'app'

app_parameter = 'app-parameter'

class kelvin.api.client.model.enum.RolePolicyAction(*values)

field_ = '*'

create = 'create'

read = 'read'

update = 'update'

delete = 'delete'

class kelvin.api.client.model.enum.LegacyAppType(*values)

kelvin = 'kelvin'

docker = 'docker'

bridge = 'bridge'

class kelvin.api.client.model.enum.ErrorLegacyType(*values)

system = 'system'

class kelvin.api.client.model.enum.Protocol(*values)

TCP = 'TCP'

UDP = 'UDP'

Manifest

class kelvin.api.client.model.manifest.AppInfo(**kwargs)

AppInfo object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)]) – StrictStr

• description (Annotated[str, Strict(strict=True)]) – StrictStr

• category (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (AppType) – enum.AppType

• kwargs (Any)

name: StrictStr

title: StrictStr

description: StrictStr

category: StrictStr | None

type: enum.AppType

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.AppIO(**kwargs)

AppIO object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• data_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• way (Way | None) – Optional[enum.Way]

• storage (Storage | None) – Optional[enum.Storage]

• unit (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

data_type: StrictStr | None

way: enum.Way | None

storage: enum.Storage | None

unit: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.DynamicAppIO(**kwargs)

DynamicAppIO object.

Parameters:

• type_name (Annotated[str, Strict(strict=True)]) – StrictStr

• data_types (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• ownership (DynamicIOOwnership | None) – Optional[enum.DynamicIOOwnership]

• type (DynamicIOType | None) – Optional[enum.DynamicIOType]

• kwargs (Any)

type_name: StrictStr

data_types: list[StrictStr] | None

ownership: enum.DynamicIOOwnership | None

type: enum.DynamicIOType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Parameter(**kwargs)

Parameter object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type (ParameterDataType | None) – Optional[enum.ParameterDataType]

• default (Annotated[str, Strict(strict=True)] | Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | None) – Optional[Union[StrictStr, StrictInt, StrictFloat, StrictBool]]

• kwargs (Any)

name: StrictStr

title: StrictStr | None

data_type: enum.ParameterDataType | None

default: StrictStr | StrictInt | StrictFloat | StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.CustomAction(**kwargs)

CustomAction object.

Parameters:

• type (Annotated[str, Strict(strict=True)]) – StrictStr

• way (CAWay | None) – Optional[enum.CAWay]

• kwargs (Any)

type: StrictStr

way: enum.CAWay | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.CustomDataQuality(**kwargs)

CustomDataQuality object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• data_type (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• datastreams (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• way (DQWay | None) – Optional[enum.DQWay]

• kwargs (Any)

name: StrictStr | None

data_type: StrictStr | None

datastreams: list[StrictStr] | None

way: enum.DQWay | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.EnableRuntimeUpdate(**kwargs)

EnableRuntimeUpdate object.

Parameters:

• configuration (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• resource_parameters (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• resource_properties (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

configuration: StrictBool | None

resource_parameters: StrictBool | None

resource_properties: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Deployment(**kwargs)

Deployment object.

Parameters:

• allowed_resources (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

allowed_resources: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Flags(**kwargs)

Flags object.

Parameters:

• spec_version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• legacy_data_types (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• legacy_extras (dict[str, Any] | None) – Optional[dict[str, Any]]

• gateway_mode (GatewayMode | None) – Optional[enum.GatewayMode]

• enable_runtime_update (EnableRuntimeUpdate | None) – Optional[EnableRuntimeUpdate]

• deployment (Deployment | None) – Optional[Deployment]

• resources_required (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• kwargs (Any)

spec_version: StrictStr | None

legacy_data_types: StrictBool | None

legacy_extras: dict[str, Any] | None

gateway_mode: enum.GatewayMode | None

enable_runtime_update: EnableRuntimeUpdate | None

deployment: Deployment | None

resources_required: StrictBool | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.AppVersion(**kwargs)

AppVersion object.

Parameters:

• version (Annotated[str, Strict(strict=True)]) – StrictStr

• flags (Flags | None) – Optional[Flags]

• io (list[AppIO] | None) – Optional[list[AppIO]]

• dynamic_io (list[DynamicAppIO] | None) – Optional[list[DynamicAppIO]]

• parameters (list[Parameter] | None) – Optional[list[Parameter]]

• custom_actions (list[CustomAction] | None) – Optional[list[CustomAction]]

• data_quality (list[CustomDataQuality] | None) – Optional[list[CustomDataQuality]]

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• kwargs (Any)

version: StrictStr

flags: Flags | None

io: list[AppIO] | None

dynamic_io: list[DynamicAppIO] | None

parameters: list[Parameter] | None

custom_actions: list[CustomAction] | None

data_quality: list[CustomDataQuality] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.IoConfiguration(**kwargs)

IoConfiguration object.

Parameters:

• type_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• schema (dict[str, Any] | None) – Optional[dict[str, Any]]

• kwargs (Any)

type_name: StrictStr | None

schema_: dict[str, Any] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Schemas(**kwargs)

Schemas object.

Parameters:

• parameters (dict[str, Any] | None) – Optional[dict[str, Any]]

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• io_configurations (list[IoConfiguration] | None) – Optional[list[IoConfiguration]]

• kwargs (Any)

parameters: dict[str, Any] | None

configuration: dict[str, Any] | None

io_configurations: list[IoConfiguration] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Cluster(**kwargs)

Cluster object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• node_name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

node_name: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.DeploymentTarget(**kwargs)

DeploymentTarget object.

Parameters:

• type (DeploymentTargetType | None) – Optional[enum.DeploymentTargetType]

• cluster (Cluster | None) – Optional[Cluster]

• kwargs (Any)

type: enum.DeploymentTargetType | None

cluster: Cluster | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.HttpHeader(**kwargs)

HttpHeader object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• value (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

value: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.HttpGet(**kwargs)

HttpGet object.

Parameters:

• path (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• port (Annotated[int, Strict(strict=True)]) – StrictInt

• scheme (URIScheme | None) – Optional[enum.URIScheme]

• http_headers (list[HttpHeader] | None) – Optional[list[HttpHeader]]

• kwargs (Any)

path: StrictStr | None

port: StrictInt

scheme: enum.URIScheme | None

http_headers: list[HttpHeader] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.TcpSocket(**kwargs)

TcpSocket object.

Parameters:

• port (Annotated[int, Strict(strict=True)]) – StrictInt

• kwargs (Any)

port: StrictInt

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Exec(**kwargs)

Exec object.

Parameters:

• command (list[Annotated[str, Strict(strict=True)]]) – list[StrictStr]

• kwargs (Any)

command: list[StrictStr]

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.LivenessProbe(**kwargs)

LivenessProbe object.

Parameters:

• initial_delay_seconds (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• period_seconds (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• timeout_seconds (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• failure_threshold (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• type (LivenessProbeType | None) – Optional[enum.LivenessProbeType]

• http_get (HttpGet | None) – Optional[HttpGet]

• tcp_socket (TcpSocket | None) – Optional[TcpSocket]

• exec (Exec | None) – Optional[Exec]

• kwargs (Any)

initial_delay_seconds: StrictInt | None

period_seconds: StrictInt | None

timeout_seconds: StrictInt | None

failure_threshold: StrictInt | None

type: enum.LivenessProbeType | None

http_get: HttpGet | None

tcp_socket: TcpSocket | None

exec: Exec | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.HealthCheck(**kwargs)

HealthCheck object.

Parameters:

• liveness_probe (LivenessProbe | None) – Optional[LivenessProbe]

• kwargs (Any)

liveness_probe: LivenessProbe | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Requests(**kwargs)

Requests object.

Parameters:

• cpu (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• memory (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

cpu: StrictStr | None

memory: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Limits(**kwargs)

Limits object.

Parameters:

• cpu (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• memory (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

cpu: StrictStr | None

memory: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Resources(**kwargs)

Resources object.

Parameters:

• requests (Requests | None) – Optional[Requests]

• limits (Limits | None) – Optional[Limits]

• kwargs (Any)

requests: Requests | None

limits: Limits | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.EnvironmentVar(**kwargs)

EnvironmentVar object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• value (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr | None

value: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Host(**kwargs)

Host object.

Parameters:

• port (Annotated[int, Strict(strict=True)]) – StrictInt

• kwargs (Any)

port: StrictInt

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Service(**kwargs)

Service object.

Parameters:

• port (Annotated[int, Strict(strict=True)]) – StrictInt

• container_port (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• exposed (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• exposed_port (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

port: StrictInt

container_port: StrictInt | None

exposed: StrictBool | None

exposed_port: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Port(**kwargs)

Port object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (PortType | None) – Optional[enum.PortType]

• host (Host | None) – Optional[Host]

• service (Service | None) – Optional[Service]

• kwargs (Any)

name: StrictStr | None

type: enum.PortType | None

host: Host | None

service: Service | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Text(**kwargs)

Text object.

Parameters:

• data (Annotated[str, Strict(strict=True)]) – StrictStr

• base64 (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• encoding (VolumeEncoding | None) – Optional[enum.VolumeEncoding]

• kwargs (Any)

data: StrictStr

base64: StrictBool | None

encoding: enum.VolumeEncoding | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.HostModel(**kwargs)

HostModel object.

Parameters:

• source (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

source: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.Volume(**kwargs)

Volume object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• target (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• type (VolumeType | None) – Optional[enum.VolumeType]

• text (Text | None) – Optional[Text]

• host (HostModel | None) – Optional[HostModel]

• kwargs (Any)

name: StrictStr | None

target: StrictStr | None

type: enum.VolumeType | None

text: Text | None

host: HostModel | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.System(**kwargs)

System object.

Parameters:

• health_check (HealthCheck | None) – Optional[HealthCheck]

• resources (Resources | None) – Optional[Resources]

• privileged (Annotated[bool, Strict(strict=True)] | None) – Optional[StrictBool]

• environment_vars (list[EnvironmentVar] | None) – Optional[list[EnvironmentVar]]

• ports (list[Port] | None) – Optional[list[Port]]

• volumes (list[Volume] | None) – Optional[list[Volume]]

• kwargs (Any)

health_check: HealthCheck | None

resources: Resources | None

privileged: StrictBool | None

environment_vars: list[EnvironmentVar] | None

ports: list[Port] | None

volumes: list[Volume] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.DeploymentModel(**kwargs)

DeploymentModel object.

Parameters:

• max_resources (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• deployment_type (DeploymentType | None) – Optional[enum.DeploymentType]

• target (DeploymentTarget | None) – Optional[DeploymentTarget]

• kwargs (Any)

max_resources: StrictInt | None

deployment_type: enum.DeploymentType | None

target: DeploymentTarget | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.IoDatastreamMappingItem(**kwargs)

IoDatastreamMappingItem object.

Parameters:

• io (Annotated[str, Strict(strict=True)]) – StrictStr

• datastream (Annotated[str, Strict(strict=True)]) – StrictStr

• kwargs (Any)

io: StrictStr

datastream: StrictStr

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.App(**kwargs)

App object.

Parameters:

• configuration (dict[str, Any] | None) – Optional[dict[str, Any]]

• io_datastream_mapping (list[IoDatastreamMappingItem] | None) – Optional[list[IoDatastreamMappingItem]]

• kwargs (Any)

configuration: dict[str, Any] | None

io_datastream_mapping: list[IoDatastreamMappingItem] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.ApiPermission(root)

Parameters:

root (list[P])

root: StrictStr

model_config = {'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class kelvin.api.client.model.manifest.Defaults(**kwargs)

Defaults object.

Parameters:

• deployment (DeploymentModel | None) – Optional[DeploymentModel]

• app (App | None) – Optional[App]

• system (System | None) – Optional[System]

• api_permissions (list[ApiPermission] | None) – Optional[list[ApiPermission]]

• kwargs (Any)

deployment: DeploymentModel | None

app: App | None

system: System | None

api_permissions: list[ApiPermission] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.manifest.AppManifest(**kwargs)

AppManifest object.

Parameters:

• schemas (Schemas | None) – Optional[Schemas]

• defaults (Defaults | None) – Optional[Defaults]

• name (Annotated[str, Strict(strict=True)])

• title (Annotated[str, Strict(strict=True)])

• description (Annotated[str, Strict(strict=True)])

• category (Annotated[str, Strict(strict=True)] | None)

• type (AppType)

• version (Annotated[str, Strict(strict=True)])

• flags (Flags | None)

• io (list[AppIO] | None)

• dynamic_io (list[DynamicAppIO] | None)

• parameters (list[Parameter] | None)

• custom_actions (list[CustomAction] | None)

• data_quality (list[CustomDataQuality] | None)

• kwargs (Any)

schemas: Schemas | None

defaults: Defaults | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

Pagination

class kelvin.api.client.model.pagination.PaginationCursor(**kwargs)

PaginationCursor object.

Parameters:

• next_page (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• previous_page (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

next_page: StrictStr | None

previous_page: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.pagination.PaginationLimits(**kwargs)

PaginationLimits object.

Parameters:

• page_size (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• page (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• total_pages (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• total_items (Annotated[int, Strict(strict=True)] | None) – Optional[StrictInt]

• kwargs (Any)

page_size: StrictInt | None

page: StrictInt | None

total_pages: StrictInt | None

total_items: StrictInt | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

PostParams

class kelvin.api.client.model.postparams.App(**kwargs)

App object.

Parameters:

• name (Annotated[str, Strict(strict=True)]) – StrictStr

• version (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• kwargs (Any)

name: StrictStr

version: StrictStr | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.postparams.AppVersionParameterListBase(**kwargs)

AppVersionParameterListBase object.

Parameters:

• apps (list[App] | None) – Optional[list[App]]

• resources (list[KRN] | None) – Optional[list[KRN]]

• parameter_names (list[Annotated[str, Strict(strict=True)]] | None) – Optional[list[StrictStr]]

• kwargs (Any)

apps: list[App] | None

resources: list[KRN] | None

parameter_names: list[StrictStr] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

Response

class kelvin.api.client.model.response.ErrorObject(**kwargs)

ErrorObject object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• solution (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (dict[str, Any] | list[Annotated[int, Strict(strict=True)] | Annotated[float, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Annotated[bool, Strict(strict=True)] | dict[str, Any]] | None) – Optional[Union[dict[str, Any], list[Union[StrictInt, StrictFloat, StrictStr, StrictBool, dict[str, Any]]]]]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

solution: StrictStr | None

payload: dict[str, Any] | list[StrictInt | StrictFloat | StrictStr | StrictBool | dict[str, Any]] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.response.Error(**kwargs)

Error object.

Parameters:

• errors (list[ErrorObject] | None) – Optional[list[ErrorObject]]

• kwargs (Any)

errors: list[ErrorObject] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.response.ErrorModel(**kwargs)

ErrorModel object.

Parameters:

• name (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• title (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• description (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• solution (Annotated[str, Strict(strict=True)] | None) – Optional[StrictStr]

• payload (list[dict[str, Any]] | None) – Optional[list[dict[str, Any]]]

• type (ErrorLegacyType | None) – Optional[enum.ErrorLegacyType]

• kwargs (Any)

name: StrictStr | None

title: StrictStr | None

description: StrictStr | None

solution: StrictStr | None

payload: list[dict[str, Any]] | None

type: enum.ErrorLegacyType | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None

class kelvin.api.client.model.response.ErrorLegacy(**kwargs)

ErrorLegacy object.

Parameters:

• errors (list[ErrorModel] | None) – Optional[list[ErrorModel]]

• kwargs (Any)

errors: list[ErrorModel] | None

model_config = {'extra': 'allow', 'populate_by_name': True, 'use_enum_values': True, 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_post_init(context, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self (BaseModel) – The BaseModel instance.

• context (Any) – The context.

Return type:

None