Models

class flame_hub.models.CreateNode(*, externalName: str | None, hidden: bool | None, name: str, realmId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], registryId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], type: Literal['aggregator', 'default'] | None)

Bases: CoreBaseModel

external_name: str | None

hidden: bool | None

name: str

realm_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

type: Literal['aggregator', 'default'] | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Node(*, externalName: str | None, hidden: bool | None, name: str, realmId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], registryId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], type: Literal['aggregator', 'default'] | None, id: UUID, publicKey: str | None, online: bool, registry: Annotated[Registry | None, IsIncludable] = None, registryProjectId: UUID | None, registryProject: Annotated[RegistryProject | None, IsIncludable] = None, clientId: UUID | None, createdAt: datetime, updatedAt: datetime)

Bases: CreateNode

id: UUID

public_key: str | None

online: bool

registry: Annotated[Registry | None, IsIncludable]

registry_project_id: UUID | None

registry_project: Annotated[RegistryProject | None, IsIncludable]

client_id: UUID | None

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateNode(*, hidden: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, externalName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, type: ~typing.Literal['aggregator', 'default'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, publicKey: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, realmId: ~typing.Annotated[~uuid.UUID | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, registryId: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

hidden: bool | type[UNSET]

external_name: str | None | type[UNSET]

type: Literal['aggregator', 'default'] | type[UNSET]

public_key: str | None | type[UNSET]

realm_id: Annotated[UUID | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.MasterImageGroup(*, id: UUID, name: str, path: str, virtualPath: str, createdAt: datetime, updatedAt: datetime)

Bases: CoreBaseModel

id: UUID

name: str

path: str

virtual_path: str

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.MasterImage(*, id: UUID, path: str | None, virtualPath: str, groupVirtualPath: str, buildStatus: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None, buildProgress: int | None, name: str, command: str | None, commandArguments: Annotated[list[MasterImageCommandArgument] | None, BeforeValidator(func=ensure_position_none, json_schema_input_type=PydanticUndefined)], createdAt: datetime, updatedAt: datetime)

Bases: CoreBaseModel

id: UUID

path: str | None

virtual_path: str

group_virtual_path: str

build_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None

build_progress: int | None

name: str

command: str | None

command_arguments: Annotated[list[MasterImageCommandArgument] | None, BeforeValidator(func=ensure_position_none, json_schema_input_type=PydanticUndefined)]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateProjectNode(*, nodeId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], projectId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: CoreBaseModel

node_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

project_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateProject(*, description: str | None, masterImageId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], name: str, displayName: str | None)

Bases: CoreBaseModel

description: str | None

master_image_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

name: str

display_name: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Project(*, description: str | None, masterImageId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], name: str, displayName: str | None, id: UUID, analyses: int, nodes: int, masterImage: Annotated[MasterImage | None, IsIncludable] = None, createdAt: datetime, updatedAt: datetime, realmId: UUID, userId: UUID | None)

Bases: CreateProject

id: UUID

analyses: int

nodes: int

master_image: Annotated[MasterImage | None, IsIncludable]

created_at: datetime

updated_at: datetime

realm_id: UUID

user_id: UUID | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateProject(*, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, masterImageId: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

description: str | None | type[UNSET]

master_image_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

name: str | type[UNSET]

display_name: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.ProjectNode(*, nodeId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], projectId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, approvalStatus: Literal['rejected', 'approved'] | None, comment: str | None, createdAt: datetime, updatedAt: datetime, node: Annotated[Node | None, IsIncludable] = None, project: Annotated[Project | None, IsIncludable] = None, projectRealmId: UUID, nodeRealmId: UUID)

Bases: CreateProjectNode

id: UUID

approval_status: Literal['rejected', 'approved'] | None

comment: str | None

created_at: datetime

updated_at: datetime

node: Annotated[Node | None, IsIncludable]

project: Annotated[Project | None, IsIncludable]

project_realm_id: UUID

node_realm_id: UUID

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysis(*, description: str | None, name: str | None, displayName: str | None, projectId: ~typing.Annotated[~uuid.UUID, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], masterImageId: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], registryId: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], imageCommandArguments: ~typing.Annotated[list[~flame_hub._core_client.MasterImageCommandArgument], ~pydantic.functional_validators.BeforeValidator(func=~flame_hub._core_client.CreateAnalysis.<lambda>, json_schema_input_type=PydanticUndefined)] = <factory>)

Bases: CoreBaseModel

description: str | None

name: str | None

display_name: str | None

project_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

master_image_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

image_command_arguments: <lambda>, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Analysis(*, description: str | None, name: str | None, displayName: str | None, projectId: ~uuid.UUID, masterImageId: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], registryId: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], imageCommandArguments: ~typing.Annotated[list[~flame_hub._core_client.MasterImageCommandArgument], ~pydantic.functional_validators.BeforeValidator(func=~flame_hub._core_client.CreateAnalysis.<lambda>, json_schema_input_type=PydanticUndefined)] = <factory>, id: ~uuid.UUID, nodes: int, nodesApproved: int, configurationLocked: bool, configurationEntrypointValid: bool, configurationImageValid: bool, configurationNodeAggregatorValid: bool, configurationNodeDefaultValid: bool, configurationNodesValid: bool, buildStatus: ~typing.Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None, buildNodesValid: bool, buildProgress: int | None, buildHash: str | None, buildOs: str | None, buildSize: int | None, distributionStatus: ~typing.Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None, distributionProgress: int | None, executionStatus: ~typing.Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None, executionProgress: int | None, createdAt: ~datetime.datetime, updatedAt: ~datetime.datetime, registry: ~typing.Annotated[~flame_hub._core_client.Registry | None, ~flame_hub._base_client.IsIncludable] = None, realmId: ~uuid.UUID, userId: ~uuid.UUID, clientId: ~uuid.UUID | None, project: ~typing.Annotated[~flame_hub._core_client.Project | None, ~flame_hub._base_client.IsIncludable] = None, masterImage: ~typing.Annotated[~flame_hub._core_client.MasterImage | None, ~flame_hub._base_client.IsIncludable] = None)

Bases: CreateAnalysis

id: UUID

nodes: int

nodes_approved: int

configuration_locked: bool

configuration_entrypoint_valid: bool

configuration_image_valid: bool

configuration_node_aggregator_valid: bool

configuration_node_default_valid: bool

configuration_nodes_valid: bool

build_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None

build_nodes_valid: bool

build_progress: int | None

build_hash: str | None

build_os: str | None

build_size: int | None

distribution_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None

distribution_progress: int | None

execution_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None

execution_progress: int | None

created_at: datetime

updated_at: datetime

registry: Annotated[Registry | None, IsIncludable]

realm_id: UUID

user_id: UUID

client_id: UUID | None

project_id: UUID

project: Annotated[Project | None, IsIncludable]

master_image: Annotated[MasterImage | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysis(*, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, masterImageId: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, imageCommandArguments: ~typing.Annotated[list[~flame_hub._core_client.MasterImageCommandArgument], ~pydantic.functional_validators.BeforeValidator(func=~flame_hub._core_client.UpdateAnalysis.<lambda>, json_schema_input_type=PydanticUndefined)] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

description: str | None | type[UNSET]

name: str | type[UNSET]

display_name: str | None | type[UNSET]

master_image_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

image_command_arguments: UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisNode(*, analysisId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], nodeId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: CoreBaseModel

analysis_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

node_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisNode(*, analysisId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], nodeId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, approvalStatus: Literal['rejected', 'approved'] | None, executionStatus: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None, executionProgress: int | None, comment: str | None, artifactTag: str | None, artifactDigest: str | None, createdAt: datetime, updatedAt: datetime, analysis: Annotated[Analysis | None, IsIncludable] = None, node: Annotated[Node | None, IsIncludable] = None, analysisRealmId: UUID, nodeRealmId: UUID)

Bases: CreateAnalysisNode

id: UUID

approval_status: Literal['rejected', 'approved'] | None

execution_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None

execution_progress: int | None

comment: str | None

artifact_tag: str | None

artifact_digest: str | None

created_at: datetime

updated_at: datetime

analysis: Annotated[Analysis | None, IsIncludable]

node: Annotated[Node | None, IsIncludable]

analysis_realm_id: UUID

node_realm_id: UUID

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysisNode(*, comment: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, approvalStatus: ~typing.Literal['rejected', 'approved'] | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, executionStatus: ~typing.Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, executionProgress: int | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

comment: str | None | type[UNSET]

approval_status: Literal['rejected', 'approved'] | None | type[UNSET]

execution_status: Literal['starting', 'started', 'stopping', 'stopped', 'executing', 'executed', 'failed'] | None | type[UNSET]

execution_progress: int | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisNodeLog(*, analysisId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], nodeId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], code: str | None, status: str | None, message: str, level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug'])

Bases: CoreBaseModel

analysis_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

node_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

code: str | None

status: str | None

message: str

level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug']

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Log(*, time: str, message: str, service: str, channel: Literal['http', 'websocket', 'background', 'system'], level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug'], labels: dict[str, str | None])

Bases: CoreBaseModel

time: str

message: str

service: str

channel: Literal['http', 'websocket', 'background', 'system']

level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug']

labels: dict[str, str | None]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisBucketType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

CODE = 'CODE'

RESULT = 'RESULT'

TEMP = 'TEMP'

class flame_hub.models.CreateAnalysisBucket(*, type: AnalysisBucketType, bucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], analysisId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: CoreBaseModel

type: AnalysisBucketType

bucket_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

analysis_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisBucket(*, type: AnalysisBucketType, bucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], analysisId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, createdAt: datetime, updatedAt: datetime, analysis: Annotated[Analysis, IsIncludable] | None = None, realmId: UUID)

Bases: CreateAnalysisBucket

id: UUID

created_at: datetime

updated_at: datetime

analysis: Annotated[Analysis, IsIncludable] | None

realm_id: UUID

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisBucketFile(*, path: str, bucketFileId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], bucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], analysisBucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], root: bool)

Bases: CoreBaseModel

path: str

bucket_file_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

bucket_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

analysis_bucket_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

root: bool

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisBucketFile(*, path: str, bucketFileId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], bucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], analysisBucketId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], root: bool, id: UUID, createdAt: datetime, updatedAt: datetime, analysisBucket: Annotated[AnalysisBucket | None, IsIncludable] = None, realmId: UUID, userId: UUID | None, clientId: UUID | None, analysisId: UUID, analysis: Annotated[Analysis | None, IsIncludable] = None)

Bases: CreateAnalysisBucketFile

id: UUID

created_at: datetime

updated_at: datetime

analysis_bucket: Annotated[AnalysisBucket | None, IsIncludable]

realm_id: UUID

user_id: UUID | None

client_id: UUID | None

analysis_id: UUID

analysis: Annotated[Analysis | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysisBucketFile(*, root: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

root: bool | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRegistry(*, name: str, host: str, accountName: str | None, accountSecret: Annotated[str | None, IsOptionalField] = None)

Bases: CoreBaseModel

name: str

host: str

account_name: str | None

account_secret: Annotated[str | None, IsOptionalField]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Registry(*, name: str, host: str, accountName: str | None, accountSecret: Annotated[str | None, IsOptionalField] = None, id: UUID, createdAt: datetime, updatedAt: datetime)

Bases: CreateRegistry

id: UUID

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRegistry(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, host: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, accountName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, accountSecret: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

name: str | type[UNSET]

host: str | type[UNSET]

account_name: str | None | type[UNSET]

account_secret: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRegistryProject(*, name: str, type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'], registryId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], externalName: str, accountName: str | None, accountSecret: Annotated[str | None, IsOptionalField] = None)

Bases: CoreBaseModel

name: str

type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node']

registry_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

external_name: str

account_name: str | None

account_secret: Annotated[str | None, IsOptionalField]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RegistryProject(*, name: str, type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'], registryId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], externalName: str, accountName: str | None, accountSecret: Annotated[str | None, IsOptionalField] = None, id: UUID, public: bool, externalId: str | None, accountId: str | None, webhookName: str | None, webhookExists: bool | None, realmId: UUID | None, registry: Annotated[Registry | None, IsIncludable] = None, createdAt: datetime, updatedAt: datetime)

Bases: CreateRegistryProject

id: UUID

public: bool

external_id: str | None

account_id: str | None

webhook_name: str | None

webhook_exists: bool | None

realm_id: UUID | None

registry: Annotated[Registry | None, IsIncludable]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRegistryProject(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, type: ~typing.Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, registryId: ~typing.Annotated[~uuid.UUID | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, externalName: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, accountName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, accountSecret: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

name: str | type[UNSET]

type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'] | type[UNSET]

registry_id: Annotated[UUID | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

external_name: str | type[UNSET]

account_name: str | None | type[UNSET]

account_secret: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateBucket(*, name: str, region: str | None)

Bases: StorageBaseModel

name: str

region: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.BucketFile(*, id: UUID, name: str, path: str, hash: str, directory: str, size: int | None, createdAt: datetime, updatedAt: datetime, actorType: str, actorId: UUID, realmId: UUID, bucketId: UUID, bucket: Annotated[Bucket | None, IsIncludable] = None)

Bases: StorageBaseModel

id: UUID

name: str

path: str

hash: str

directory: str

size: int | None

created_at: datetime

updated_at: datetime

actor_type: str

actor_id: UUID

realm_id: UUID

bucket_id: UUID

bucket: Annotated[Bucket | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Bucket(*, name: str, region: str | None, id: UUID, createdAt: datetime, updatedAt: datetime, actorId: UUID | None, actorType: str | None, realmId: UUID | None)

Bases: CreateBucket

id: UUID

created_at: datetime

updated_at: datetime

actor_id: UUID | None

actor_type: str | None

realm_id: UUID | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UNSET

Bases: BaseModel

Sentinel to mark parameters as unset as opposed to using None.

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRealm(*, name: str, displayName: str | None, description: str | None)

Bases: AuthBaseModel

name: str

display_name: str | None

description: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRealm(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: AuthBaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Realm(*, name: str, displayName: str | None, description: str | None, id: UUID, builtIn: bool, createdAt: datetime, updatedAt: datetime)

Bases: CreateRealm

id: UUID

built_in: bool

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreatePermission(*, name: str, displayName: str | None, description: str | None, realmId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], policyId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: AuthBaseModel

name: str

display_name: str | None

description: str | None

realm_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

policy_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Permission(*, name: str, displayName: str | None, description: str | None, realmId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], policyId: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, builtIn: bool, clientId: UUID | None, createdAt: datetime, updatedAt: datetime, realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreatePermission

id: UUID

built_in: bool

client_id: UUID | None

created_at: datetime

updated_at: datetime

realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdatePermission(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, realmId: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, policyId: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>)

Bases: AuthBaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

realm_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

policy_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRole(*, name: str, displayName: str | None, description: str | None)

Bases: AuthBaseModel

name: str

display_name: str | None

description: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Role(*, name: str, displayName: str | None, description: str | None, id: UUID, target: str | None, realmId: UUID | None, createdAt: datetime, updatedAt: datetime, realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRole

id: UUID

target: str | None

realm_id: UUID | None

created_at: datetime

updated_at: datetime

realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRole(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: AuthBaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRolePermission(*, roleId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permissionId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: AuthBaseModel

role_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

permission_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RolePermission(*, roleId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permissionId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, roleRealmId: UUID | None, permissionRealmId: UUID | None, policyId: UUID | None, createdAt: datetime, updatedAt: datetime, role: Annotated[Role | None, IsIncludable] = None, roleRealm: Annotated[Realm | None, IsIncludable] = None, permission: Annotated[Permission | None, IsIncludable] = None, permissionRealm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRolePermission

id: UUID

role_realm_id: UUID | None

permission_realm_id: UUID | None

policy_id: UUID | None

created_at: datetime

updated_at: datetime

role: Annotated[Role | None, IsIncludable]

role_realm: Annotated[Realm | None, IsIncludable]

permission: Annotated[Permission | None, IsIncludable]

permission_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUser(*, name: str, displayName: str | None, email: Annotated[EmailStr | None, IsOptionalField] = None, active: bool, nameLocked: bool, firstName: str | None, lastName: str | None)

Bases: AuthBaseModel

name: str

display_name: str | None

email: Annotated[EmailStr | None, IsOptionalField]

active: bool

name_locked: bool

first_name: str | None

last_name: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.User(*, name: str, displayName: str | None, email: Annotated[EmailStr | None, IsOptionalField] = None, active: bool, nameLocked: bool, firstName: str | None, lastName: str | None, id: UUID, avatar: str | None, cover: str | None, realmId: UUID, realm: Annotated[Realm | None, IsIncludable] = None, createdAt: datetime, updatedAt: datetime)

Bases: CreateUser

id: UUID

avatar: str | None

cover: str | None

realm_id: UUID

realm: Annotated[Realm | None, IsIncludable]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateUser(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, email: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, active: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, nameLocked: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, firstName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, lastName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, password: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: AuthBaseModel

name: str | type[UNSET]

display_name: str | type[UNSET]

email: str | None | type[UNSET]

active: bool | type[UNSET]

name_locked: bool | type[UNSET]

first_name: str | None | type[UNSET]

last_name: str | None | type[UNSET]

password: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUserPermission(*, userId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permissionId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: AuthBaseModel

user_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

permission_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UserPermission(*, userId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permissionId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, userRealmId: UUID | None, permissionRealmId: UUID | None, policyId: UUID | None, createdAt: datetime, updatedAt: datetime, permission: Annotated[Permission | None, IsIncludable] = None, user: Annotated[User | None, IsIncludable] = None, permissionRealm: Annotated[Realm | None, IsIncludable] = None, userRealm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateUserPermission

id: UUID

user_realm_id: UUID | None

permission_realm_id: UUID | None

policy_id: UUID | None

created_at: datetime

updated_at: datetime

permission: Annotated[Permission | None, IsIncludable]

user: Annotated[User | None, IsIncludable]

permission_realm: Annotated[Realm | None, IsIncludable]

user_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUserRole(*, userId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], roleId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: AuthBaseModel

user_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

role_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UserRole(*, userId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], roleId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, userRealmId: UUID | None, roleRealmId: UUID | None, createdAt: datetime, updatedAt: datetime, user: Annotated[User, IsIncludable] | None = None, role: Annotated[Role, IsIncludable] | None = None, userRealm: Annotated[Realm | None, IsIncludable] = None, roleRealm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateUserRole

id: UUID

user_realm_id: UUID | None

role_realm_id: UUID | None

created_at: datetime

updated_at: datetime

user: Annotated[User, IsIncludable] | None

role: Annotated[Role, IsIncludable] | None

user_realm: Annotated[Realm | None, IsIncludable]

role_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.IsOptionalField

Bases: object

Sentinel to annotate model attributes as optional fields.

class flame_hub.models.IsIncludable

Bases: object

Sentinel to annotate model attributes as includable.

class flame_hub.models.ResourceListMeta(*, schema: dict, total: int, limit: int, offset: int)

Bases: SingleResourceMeta

Resource for meta information on list responses.

See also

_get_all_resources(), _find_all_resources(), SingleResourceMeta

total: int: The total amount of records of a specific resource type.

limit: int: Amount of returned resources.

offset: int: Amount of resources to skip before resources are added to the returned list.

model_config: ClassVar[ConfigDict] = {'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AccessToken(*, access_token: str, expires_in: int, token_type: str, scope: str)

Bases: BaseModel

access_token: str

expires_in: int

token_type: str

scope: str

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RefreshToken(*, access_token: str, expires_in: int, token_type: str, scope: str, refresh_token: str)

Bases: AccessToken

refresh_token: str

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateClient(*, name: str, secret: str | None, displayName: str | None, description: str | None, redirectUri: str | None, active: bool, isConfidential: bool, secretHashed: bool, grantTypes: str | None, authMethod: Literal['none', 'secret', 'tls'], tokenBindingMethod: Literal['none', 'tls'], realmId: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: AuthBaseModel

name: str

secret: str | None

display_name: str | None

description: str | None

redirect_uri: str | None

active: bool

is_confidential: bool

secret_hashed: bool

grant_types: str | None

auth_method: Literal['none', 'secret', 'tls']

token_binding_method: Literal['none', 'tls']

realm_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateClient(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, secret: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, redirectUri: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, active: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, isConfidential: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, secretHashed: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, grantTypes: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, authMethod: ~typing.Literal['none', 'secret', 'tls'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, tokenBindingMethod: ~typing.Literal['none', 'tls'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: AuthBaseModel

name: str | type[UNSET]

secret: str | None | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

redirect_uri: str | None | type[UNSET]

active: bool | type[UNSET]

is_confidential: bool | type[UNSET]

secret_hashed: bool | type[UNSET]

grant_types: str | None | type[UNSET]

auth_method: Literal['none', 'secret', 'tls'] | type[UNSET]

token_binding_method: Literal['none', 'tls'] | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Client(*, id: UUID, name: str, builtIn: bool, displayName: str | None, description: str | None, redirectUri: str | None, active: bool, secretHashed: bool, grantTypes: str | None, secretEncrypted: bool, scope: str | None, baseUrl: str | None, rootUrl: str | None, authMethod: Literal['none', 'secret', 'tls'], tokenBindingMethod: Literal['none', 'tls'], createdAt: datetime, updatedAt: datetime, realmId: UUID, realm: Annotated[Realm | None, IsIncludable] = None)

Bases: AuthBaseModel

id: UUID

name: str

built_in: bool

display_name: str | None

description: str | None

redirect_uri: str | None

active: bool

secret_hashed: bool

grant_types: str | None

secret_encrypted: bool

scope: str | None

base_url: str | None

root_url: str | None

auth_method: Literal['none', 'secret', 'tls']

token_binding_method: Literal['none', 'tls']

created_at: datetime

updated_at: datetime

realm_id: UUID

realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.NodeRegistryCredentials(*, host: str, externalName: str, accountName: str | None, accountSecret: str | None)

Bases: CoreBaseModel

host: str

external_name: str

account_name: str | None

account_secret: str | None

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.ClientCredentials(*, id: UUID, secret: str | None, name: str, displayName: str)

Bases: CoreBaseModel

id: UUID

secret: str | None

name: str

display_name: str

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateClientCredentials(*, secret: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, displayName: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: CoreBaseModel

secret: str | None | type[UNSET]

name: str | type[UNSET]

display_name: str | type[UNSET]

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.ConfigBaseModel

Bases: BaseModel

Base model that defines all configurations that are inherited to all model classes.

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AuthBaseModel

Bases: ConfigBaseModel

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CoreBaseModel

Bases: ConfigBaseModel

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.StorageBaseModel

Bases: ConfigBaseModel

model_config: ClassVar[ConfigDict] = {'alias_generator': <function to_camel>, 'serialize_by_alias': True, 'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.SingleResourceMeta(*, schema: dict)

Bases: BaseModel

Available meta info for single resource responses.

See also

_get_single_resource()

model_config: ClassVar[ConfigDict] = {'validate_by_alias': True, 'validate_by_name': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

response_schema: dict

class flame_hub.models.ResourceList(*, data: list[ResourceT], meta: ResourceListMeta)

Bases: BaseModel, Generic[ResourceT]

Model for list responses.

See also

_get_all_resources(), _find_all_resources(), ResourceListMeta

data: list[ResourceT]: Attribute which holds all retrieved resources as a list.

meta: ResourceListMeta: Attribute which holds meta information about the result and the requested resource type.

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.WrappedResource(*, data: ResourceT, meta: SingleResourceMeta)

Bases: BaseModel, Generic[ResourceT]

Model for wrapped singular resources.

See also

_get_singular_resource(), SingleResourceMeta

data: ResourceT: Attribute which holds the retrieved resource.

meta: SingleResourceMeta: Attribute which holds meta information about the requested resource.

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].