Data model

class V1DeletePipelineResponse(BaseModel):

    """
    Response model for deleting a pipeline.
    This model contains fields to indicate the status of the delete operation,
    any errors that occurred, and a message providing additional information.

    Attributes:
        status (Optional[str]): Status of the delete operation.
        Status (Optional[str]): Alternative case for status of the delete operation.
        Error (Optional[Dict[Any, Any]]): Error message if the delete operation fails.
        success (Optional[bool]): Indicates if the delete operation was successful.
        message (Optional[str]): Message providing additional information about the operation.
    """
    status: Optional[str] = Field(
        default_factory=str, description="Status of the delete operation"
    )
    Status: Optional[str] = Field(
        default_factory=str,
        description="Status of the delete operation (alternative case)",
    )
    Error: Optional[Dict[Any, Any]] = Field(
        default_factory=dict, description="Error message if the delete operation fails"
    )
    success: Optional[bool] = Field(
        default=None, description="Indicates if the delete operation was successful"
    )
    message: Optional[str] = Field(
        default=None, description="Message providing additional information about the operation"
    )

class FilterItem(BaseModel):
    """
    Represents a filter item used in event filtering for pipelines.
    Attributes:
        objectSuffix (List[str]): List of suffixes for objects to filter.
        maxObjectSize (int): Maximum size of the object to filter.
    """
    objectSuffix: List[str]
    maxObjectSize: Optional[int] = Field(default=None)

class V1CreatePipeline(BaseModel):
    """
    Represents a request to create a pipeline.
    Attributes:
        name (str): Name of the pipeline.
        type (str): Type of the pipeline.
        model (Optional[str]): Optional model associated with the pipeline.
        eventFilter (FilterItem): Event filter criteria for the pipeline.
        schema_name (str): Schema for the pipeline (serialized as 'schema').
        customFunction (Optional[str]): Optional custom function for the pipeline.
        prompt (Optional[str]): Prompt for transcribe pipelines (e.g., 'transcribe-metadata' type).
        chunkSize (Optional[int]): Chunk size for RAG pipelines.
        chunkOverlap (Optional[int]): Chunk overlap for RAG pipelines.
    """
    model_config = ConfigDict(populate_by_name=True)

    name: str
    type: str
    model: Optional[str]
    eventFilter: FilterItem
    schema_name: str = Field(validation_alias="schema", serialization_alias="schema")
    customFunction: Optional[str]
    prompt: Optional[str] = Field(
        default=None,
        description="Prompt for transcribe pipelines",
    )
    chunkSize: Optional[int] = Field(
        default=None,
        description="Chunk size for RAG pipelines",
    )
    chunkOverlap: Optional[int] = Field(
        default=None,
        description="Chunk overlap for RAG pipelines",
    )

class V1CreatePipelineResponse(BaseModel):
    """
    Response model for creating a pipeline.
    This model contains fields to indicate the success of the creation operation
    and a message providing additional information.

    Attributes:
        success (bool): Indicates if the pipeline creation was successful.
        message (str): Message providing additional information about the operation.
    """
    success: bool
    message: str

class BucketUpdateResponse(BaseModel):
    """
    Response model for updating buckets in a collection.
    This model contains fields to indicate the success of the update operation
    and a message providing additional information.
    Attributes:
        success (bool): Indicates if the bucket update was successful.
        message (str): Message providing additional information about the operation.
    """
    success: bool
    message: str

class NodeWithScore(BaseModel):
    """
    Represents a node with its associated score and metadata.
    Attributes:
        score (float): Score associated with the node.
        dataChunk (str): Data chunk associated with the node.
        chunkMetadata (Optional[Dict[str, Any]]): Optional metadata associated with the data chunk
    """
    score: float
    dataChunk: str
    chunkMetadata: Optional[Dict[str, Any]] = Field(default_factory=dict)

class V1SimilaritySearchResponse(BaseModel):
    """
    Response model for similarity search in a collection.
    This model contains fields to indicate the success of the search operation,
    a message providing additional information, and the results of the search.
    Attributes:
        success (bool): Indicates if the similarity search was successful.
        message (str): Message providing additional information about the operation.
        results (Optional[List[NodeWithScore]]): List of nodes with their scores returned by the search.
    """
    success: bool
    message: str
    results: Optional[List[NodeWithScore]] = Field(default_factory=list)

class SchemaListItem(BaseModel):
    """
    Represents a single schema item in the list schemas response.

    Attributes:
        id (Optional[str]): Unique identifier of the schema.
        name (str): Name of the schema.
    """

    id: Optional[str] = Field(default=None, description="schema id")
    name: str = Field(..., description="schema name")

class V1ListSchemasResponse(BaseModel):
    """
    Represents a response containing a list of schema records.

    Attributes:
        schemas (List[SchemaListItem]): List of available schemas with id and name.
    """

    schemas: List[SchemaListItem]

class SchemaItem(BaseModel):
    """
    Represents a single field definition inside a schema.

    Attributes:
        name (str): Field name in the schema definition.
        type (str): Field type in the schema definition.
        nullable (bool): Whether the field allows null values. Defaults to
            ``True``. Set to ``False`` to mark the field as required (the
            underlying database column is created as ``NOT NULL`` and schema
            validation is strict for that field).
    """

    name: str = Field(..., description="field name")
    type: str = Field(..., description="field type")
    nullable: bool = Field(
        default=True, description="whether the field allows null values"
    )

class V1SchemasResponse(BaseModel):
    """
    Represents a detailed schema response.

    This model contains the schema name, schema type, and the list of
    schema fields returned by the API.

    Attributes:
        name (str): Name of the schema.
        type (Optional[str]): Schema type (for example, `rag` or `transcribe-metadata`).
        schema_fields (List[SchemaItem]): List of schema fields (serialized as `schema`).
    """

    model_config = ConfigDict(populate_by_name=True)

    name: str = Field(..., description="schema name")
    type: Optional[str] = Field(
        default=None,
        description="Schema type (e.g., 'rag', 'transcribe-metadata')",
    )
    schema_fields: List[SchemaItem] = Field(
        ..., alias="schema", description="list of schema fields"
    )

class V1CreateSchemaRequest(BaseModel):
    """
    Request body for creating a new schema.

    Attributes:
        name (str): Name of the schema to create.
        type (str): Schema type (for example, `rag` or `transcribe-metadata`).
        schema_fields (List[SchemaItem]): List of schema fields (serialized as `schema`).
    """

    model_config = ConfigDict(populate_by_name=True)

    name: str = Field(..., description="schema name")
    type: str = Field(..., description="schema type (e.g., 'custom-function')")
    schema_fields: List[SchemaItem] = Field(..., validation_alias="schema", serialization_alias="schema", description="list of schema fields")

class V1CreateSchemaResponse(BaseModel):
    """
    Response returned after attempting to create a schema.

    Attributes:
        status (int): HTTP status code of the operation.
        message (str): Status message from the server.
        success (bool): Indicates whether schema creation succeeded.
        error (Dict[str, Any]): Error details if the operation fails.
    """

    status: int = Field(default=200, description="HTTP status code")
    message: str = Field(default="", description="Status message from the server")
    success: bool = Field(default=True, description="Indicates if the create operation was successful")
    error: Dict[str, Any] = Field(default_factory=dict, description="Error details if the operation fails")

class V1DeleteSchemaResponse(BaseModel):
    """
    Response returned after attempting to delete a schema.

    Attributes:
        status (int): HTTP status code of the operation.
        message (str): Status message from the server.
        success (bool): Indicates if the delete operation was successful.
        error (Dict[str, Any]): Error details if the delete operation fails.
    """

    status: int = Field(default=200, description="HTTP status code")
    message: str = Field(default="", description="Status message from the server")
    success: bool = Field(default=True, description="Indicates if the delete operation was successful")
    error: Dict[str, Any] = Field(default_factory=dict, description="Error details if the delete operation fails")

class V1ModelsResponse(BaseModel):
    """
    Response model for listing available models.
    This model contains fields to represent the system model name, model name,
    capabilities, dimensionality, maximum tokens supported by the model, and the version of the model.
    Attributes:
        name (str): System model name.
        modelName (str): Model name.
        capabilities (List[str]): List of capabilities such as embedding, large language model, etc.
        version (str): Model version.
        communicationType (str): API communication type identifier for the model.
        dimension (int): Model dimensionality.
        contextLength (int): Context length for the model.
        temperature (float): Temperature setting for the model.
        topK (int): Top-k setting for the model.
        topP (float): Top-p setting for the model.
        maximumTokens (int): Maximum token size supported by the model.
        timeout (int): API request timeout for the model.
        language (str): Language supported by the model.
        sampleRate (int): Sampling rate for the ASR model.
        automaticPunctuation (bool): Enable automatic punctuation in the ASR model.
    """

    name: str = Field(..., description="system model name")
    modelName: str = Field(..., description="model name")
    capabilities: List[str] = Field(...,
                                    description="Sentence-Similarity, Question-Answering, Image-Text-To-Text, Custom-Function, Video-To-Text etc")
    version: str = Field(..., description="model version")
    communicationType: str = Field(..., description="API communication type identifier for the model.")
    dimension: Optional[int] = Field(..., description="model dimensionality")
    contextLength: Optional[int] = Field(..., description="context length for the model")
    temperature: Optional[float] = Field(..., description="temperature setting for the model")
    topK: Optional[int] = Field(..., description="top-k setting for the model")
    topP: Optional[float] = Field(..., description="top-p setting for the model")
    maximumTokens: Optional[int] = Field(...,
                               description="max token size supported by the model")
    timeout: Optional[int] = Field(..., description="API request timeout for the model.")
    language: Optional[str] = Field(..., description="Language supported by the model.")
    sampleRate: Optional[int] = Field(..., description="Sampling rate for the ASR model.")
    automaticPunctuation: Optional[bool] = Field(..., description="Enable automatic punctuation in the ASR model.")
    endpoint: Optional[str] = Field(default=None, description="Custom function endpoint URL")

class ModelRecordSummary(BaseModel):
    """
    Represents a summary of a model record.
    Attributes:
        id (str): Unique identifier for the model record.
        name (str): Name of the model record.
    """
    id: str
    name: str

class V1ListModelsResponse(BaseModel):
    """
    Response model for listing available models.
    This model contains a list of model records.
    Attributes:
        models (List[ModelRecordSummary]): List of model records.
    """
    models: List[ModelRecordSummary]

class V1DeleteCollectionResponse(BaseModel):
    """
    Response model for deleting a collection.
    This model contains fields to indicate the status of the delete operation,
    any errors that occurred, and a message providing additional information.
    Attributes:
        status (Optional[str]): Status of the delete operation.
        Status (Optional[str]): Alternative case for status of the delete operation.
        Error (Optional[Dict[Any, Any]]): Error message if the delete operation fails.
        success (Optional[bool]): Indicates if the delete operation was successful.
        message (Optional[str]): Message providing additional information about the operation.
    """
    status: Optional[str] = Field(
        default_factory=str, description="Status of the delete operation"
    )
    Status: Optional[str] = Field(
        default_factory=str,
        description="Status of the delete operation (alternative case)",
    )
    Error: Optional[Dict[Any, Any]] = Field(
        default_factory=dict, description="Error message if the delete operation fails"
    )
    success: Optional[bool] = Field(
        default=None, description="Indicates if the delete operation was successful"
    )
    message: Optional[str] = Field(
        default=None, description="Message providing additional information about the operation"
    )

class V1CreateCollection(BaseModel):
    """
    Represents a request to create a collection.
    Attributes:
        name (str): Name of the collection.
        pipeline (str): Pipeline associated with the collection.
        buckets (Optional[List[str]]): Optional list of buckets associated with the collection.
        outputStore (Optional[str]): Output bucket for transcription results (transcribe usecase).
        indexingMode (Optional[str]): Indexing mode for RAG collections (e.g., HNSW, GPU_CAGRA). Auto-detected if omitted.
    """
    name: str
    pipeline: str
    buckets: Optional[List[str]]
    outputStore: Optional[str] = Field(
        default=None,
        description="Output bucket for transcription results",
    )
    indexingMode: Optional[str] = Field(
        default=None,
        description="Indexing mode for RAG collections (e.g., HNSW, GPU_CAGRA). Auto-detected if omitted.",
    )

class V1CollectionResponse(BaseModel):
    """
    Represents a response containing collection information.
    This model contains fields to represent the collection name, pipeline, and an optional list of buckets
    associated with the collection.
    Attributes:
        name (str): Name of the collection.
        pipeline (str): Pipeline associated with the collection.
        buckets (Optional[List[str]]): Optional list of buckets associated with the collection.
        outputStore (Optional[str]): Output bucket for transcription results (transcribe usecase).
        indexingMode (Optional[str]): Indexing mode for RAG collections (e.g., HNSW, GPU_CAGRA).
    """
    name: str
    pipeline: str
    buckets: Optional[List[str]] = Field(
        default_factory=list,
        description="List of buckets associated with the collection",
    )
    outputStore: Optional[str] = Field(
        default=None,
        description="Output bucket for transcription results",
    )
    indexingMode: Optional[str] = Field(
        default=None,
        description="Indexing mode for RAG collections (e.g., HNSW, GPU_CAGRA)",
    )

class BucketUpdateRequest(BaseModel):
    """
    Represents a request to update the buckets of a collection.
    Attributes:
        name (str): Name of the collection.
        buckets (List[str]): List of buckets to be associated with the collection.
    """
    name: str
    buckets: List[str]

class V1PipelineResponse(BaseModel):
    """
    Represents a response containing pipeline information.
    This model contains fields to represent the pipeline name, type, model, custom function,
    event filter criteria, and schema associated with the pipeline.
    Attributes:
        name (str): Name of the pipeline.
        type (str): Type of the pipeline.
        model (Optional[str]): Optional model associated with the pipeline.
        customFunction (Optional[str]): Optional custom function for the pipeline.
        eventFilter (Dict[str, Any]): Event filter criteria for the pipeline.
        schema_name (str): Schema associated with the pipeline (serialized as 'schema').
        prompt (Optional[str]): Prompt for transcribe pipelines.
        chunkSize (Optional[int]): Chunk size for RAG pipelines.
        chunkOverlap (Optional[int]): Chunk overlap for RAG pipelines.
    """
    model_config = ConfigDict(populate_by_name=True)

    name: str
    type: str
    model: Optional[str] = Field(default=None)
    customFunction: Optional[str] = Field(default=None)
    eventFilter: Dict[str, Any]
    schema_name: str = Field(validation_alias="schema", serialization_alias="schema")
    prompt: Optional[str] = Field(default=None, description="Prompt for transcribe pipelines")
    chunkSize: Optional[int] = Field(default=None, description="Chunk size for RAG pipelines")
    chunkOverlap: Optional[int] = Field(default=None, description="Chunk overlap for RAG pipelines")

class ListCollectionItem(BaseModel):
    """
    Represents a summary of a collection item.
    Attributes:
        id (Optional[str]): Unique identifier for the collection item.
        name (Optional[str]): Name of the collection item.
    """
    id: Optional[str] = Field(None, description="collection id")
    name: Optional[str] = Field(None, description="collection name")

class ListCollection(RootModel[List[ListCollectionItem]]):
    """
    Response model for listing available collections.
    This model contains a list of collection items.
    Attributes:
        root (List[ListCollectionItem]): List of collection items.
    """
    root: List[ListCollectionItem] = Field(
        ...,
        examples=[
            [{"id": "1", "name": "collection1"}, {"id": "2", "name": "collection2"}]
        ],
    )

class ListPipeline(BaseModel):
    """
    Represents a summary of a pipeline.
    Attributes:
        id (Optional[str]): Unique identifier for the pipeline.
        name (Optional[str]): Name of the pipeline.
    """
    id: Optional[str] = Field(None, description="pipeline id")
    name: Optional[str] = Field(None, description="pipeline name")

class ListPipelines(RootModel[List[ListPipeline]]):
    """
    Response model for listing available pipelines.
    This model contains a list of pipelines.
    Attributes:
        root (List[ListPipeline]): List of pipelines.
    """
    root: List[ListPipeline] = Field(
        ...,
        examples=[[{"id": "1", "name": "pipeline1"}, {"id": "2", "name": "pipeline2"}]],
    )