glopenai - v1.0.0

glopenai/vector_store

Types

AttributeValue

</>

File attribute value: untagged String / Number / Boolean.

pub type AttributeValue {
  AttributeString(value: String)
  AttributeNumber(value: Int)
  AttributeBoolean(value: Bool)
}

Constructors 

  • AttributeString(value: String)
  • AttributeNumber(value: Int)
  • AttributeBoolean(value: Bool)

ChunkingStrategyRequestParam

</>

Tagged: auto or static with a nested static config.

pub type ChunkingStrategyRequestParam {
  AutoChunking
  StaticChunking(config: StaticChunkingStrategy)
}

Constructors

ChunkingStrategyResponse

</>

Returned on VectorStoreFileObject.chunking_strategy. Includes an Other variant for files indexed before the strategy concept existed.

pub type ChunkingStrategyResponse {
  OtherChunking
  StaticChunkingResponse(config: StaticChunkingStrategy)
}

Constructors

ComparisonFilterRecord

</> 
pub type ComparisonFilterRecord {
  ComparisonFilterRecord(
    comparison_type: ComparisonType,
    key: String,
    value: dynamic.Dynamic,
  )
}

Constructors 

  • ComparisonFilterRecord(
  comparison_type: ComparisonType,
  key: String,
  value: dynamic.Dynamic,
)

    Arguments

    value

    Value to compare against. Carry as Dynamic so callers can pass a string, number, or boolean.

ComparisonType

</> 
pub type ComparisonType {
  Equals
  NotEquals
  GreaterThan
  GreaterThanOrEqual
  LessThan
  LessThanOrEqual
  In
  NotIn
}

Constructors 

  • Equals
  • NotEquals
  • GreaterThan
  • GreaterThanOrEqual
  • LessThan
  • LessThanOrEqual
  • In
  • NotIn

CompoundFilterRecord

</> 
pub type CompoundFilterRecord {
  CompoundFilterRecord(
    compound_type: CompoundType,
    filters: List(Filter),
  )
}

Constructors

CompoundType

</> 
pub type CompoundType {
  And
  Or
}

Constructors 

  • And
  • Or

CreateVectorStoreFileBatchRequest

</> 
pub type CreateVectorStoreFileBatchRequest {
  CreateVectorStoreFileBatchRequest(
    file_ids: option.Option(List(String)),
    files: option.Option(List(CreateVectorStoreFileRequest)),
    chunking_strategy: option.Option(ChunkingStrategyRequestParam),
    attributes: option.Option(dict.Dict(String, AttributeValue)),
  )
}

Constructors

CreateVectorStoreFileRequest

</> 
pub type CreateVectorStoreFileRequest {
  CreateVectorStoreFileRequest(
    file_id: String,
    chunking_strategy: option.Option(ChunkingStrategyRequestParam),
    attributes: option.Option(dict.Dict(String, AttributeValue)),
  )
}

Constructors

CreateVectorStoreRequest

</> 
pub type CreateVectorStoreRequest {
  CreateVectorStoreRequest(
    file_ids: option.Option(List(String)),
    name: option.Option(String),
    description: option.Option(String),
    expires_after: option.Option(VectorStoreExpirationAfter),
    chunking_strategy: option.Option(ChunkingStrategyRequestParam),
    metadata: option.Option(dict.Dict(String, String)),
  )
}

Constructors

DeleteVectorStoreFileResponse

</> 
pub type DeleteVectorStoreFileResponse {
  DeleteVectorStoreFileResponse(
    id: String,
    object: String,
    deleted: Bool,
  )
}

Constructors 

  • DeleteVectorStoreFileResponse(
  id: String,
  object: String,
  deleted: Bool,
)

DeleteVectorStoreResponse

</> 
pub type DeleteVectorStoreResponse {
  DeleteVectorStoreResponse(
    id: String,
    object: String,
    deleted: Bool,
  )
}

Constructors 

  • DeleteVectorStoreResponse(
  id: String,
  object: String,
  deleted: Bool,
)

Filter

</>

A vector-store search filter. Untagged in JSON: a ComparisonFilter or a CompoundFilter.

pub type Filter {
  ComparisonFilter(filter: ComparisonFilterRecord)
  CompoundFilter(filter: CompoundFilterRecord)
}

Constructors

ListFilesFilter

</>

File status filter used by both ListVectorStoreFilesQuery and ListFilesInVectorStoreBatchQuery.

pub type ListFilesFilter {
  FilterInProgress
  FilterCompleted
  FilterFailed
  FilterCancelled
}

Constructors 

  • FilterInProgress
  • FilterCompleted
  • FilterFailed
  • FilterCancelled

ListFilesInVectorStoreBatchQuery

</> 
pub type ListFilesInVectorStoreBatchQuery {
  ListFilesInVectorStoreBatchQuery(
    limit: option.Option(Int),
    order: option.Option(ListOrder),
    after: option.Option(String),
    before: option.Option(String),
    filter: option.Option(ListFilesFilter),
  )
}

Constructors

ListOrder

</> 
pub type ListOrder {
  Asc
  Desc
}

Constructors 

  • Asc
  • Desc

ListVectorStoreFilesQuery

</> 
pub type ListVectorStoreFilesQuery {
  ListVectorStoreFilesQuery(
    limit: option.Option(Int),
    order: option.Option(ListOrder),
    after: option.Option(String),
    before: option.Option(String),
    filter: option.Option(ListFilesFilter),
  )
}

Constructors

ListVectorStoreFilesResponse

</> 
pub type ListVectorStoreFilesResponse {
  ListVectorStoreFilesResponse(
    object: String,
    data: List(VectorStoreFileObject),
    first_id: option.Option(String),
    last_id: option.Option(String),
    has_more: Bool,
  )
}

Constructors

ListVectorStoresQuery

</> 
pub type ListVectorStoresQuery {
  ListVectorStoresQuery(
    limit: option.Option(Int),
    order: option.Option(ListOrder),
    after: option.Option(String),
    before: option.Option(String),
  )
}

Constructors

ListVectorStoresResponse

</> 
pub type ListVectorStoresResponse {
  ListVectorStoresResponse(
    object: String,
    data: List(VectorStoreObject),
    first_id: option.Option(String),
    last_id: option.Option(String),
    has_more: Bool,
  )
}

Constructors

Ranker

</> 
pub type Ranker {
  RankerNone
  RankerAuto
  RankerDefault20241115
}

Constructors 

  • RankerNone
  • RankerAuto
  • RankerDefault20241115

RankingOptions

</> 
pub type RankingOptions {
  RankingOptions(
    ranker: option.Option(Ranker),
    score_threshold: option.Option(Float),
  )
}

Constructors

StaticChunkingStrategy

</>

Static chunking strategy. Mirrors Rust’s StaticChunkingStrategy.

pub type StaticChunkingStrategy {
  StaticChunkingStrategy(
    max_chunk_size_tokens: Int,
    chunk_overlap_tokens: Int,
  )
}

Constructors 

  • StaticChunkingStrategy(
  max_chunk_size_tokens: Int,
  chunk_overlap_tokens: Int,
)

UpdateVectorStoreFileAttributesRequest

</> 
pub type UpdateVectorStoreFileAttributesRequest {
  UpdateVectorStoreFileAttributesRequest(
    attributes: dict.Dict(String, AttributeValue),
  )
}

Constructors

UpdateVectorStoreRequest

</> 
pub type UpdateVectorStoreRequest {
  UpdateVectorStoreRequest(
    name: option.Option(String),
    expires_after: option.Option(VectorStoreExpirationAfter),
    metadata: option.Option(dict.Dict(String, String)),
  )
}

Constructors

VectorStoreExpirationAfter

</>

Expiration policy for vector stores or chat sessions.

pub type VectorStoreExpirationAfter {
  VectorStoreExpirationAfter(anchor: String, days: Int)
}

Constructors 

  • VectorStoreExpirationAfter(anchor: String, days: Int)

VectorStoreFileAttributes

</>

VectorStoreFileAttributes is a transparent newtype around Dict in Rust; in Gleam we just use Dict(String, AttributeValue) directly.

pub type VectorStoreFileAttributes =
  dict.Dict(String, AttributeValue)

VectorStoreFileBatchCounts

</> 
pub type VectorStoreFileBatchCounts {
  VectorStoreFileBatchCounts(
    in_progress: Int,
    completed: Int,
    failed: Int,
    cancelled: Int,
    total: Int,
  )
}

Constructors 

  • VectorStoreFileBatchCounts(
  in_progress: Int,
  completed: Int,
  failed: Int,
  cancelled: Int,
  total: Int,
)

VectorStoreFileBatchObject

</> 
pub type VectorStoreFileBatchObject {
  VectorStoreFileBatchObject(
    id: String,
    object: String,
    created_at: Int,
    vector_store_id: String,
    status: VectorStoreFileBatchStatus,
    file_counts: VectorStoreFileBatchCounts,
  )
}

Constructors

VectorStoreFileBatchStatus

</> 
pub type VectorStoreFileBatchStatus {
  BatchInProgress
  BatchCompleted
  BatchCancelled
  BatchFailed
}

Constructors 

  • BatchInProgress
  • BatchCompleted
  • BatchCancelled
  • BatchFailed

VectorStoreFileContentObject

</> 
pub type VectorStoreFileContentObject {
  VectorStoreFileContentObject(
    content_type: String,
    text: String,
  )
}

Constructors 

  • VectorStoreFileContentObject(content_type: String, text: String)

VectorStoreFileContentResponse

</> 
pub type VectorStoreFileContentResponse {
  VectorStoreFileContentResponse(
    object: String,
    data: List(VectorStoreFileContentObject),
    has_more: Bool,
    next_page: option.Option(String),
  )
}

Constructors

VectorStoreFileCounts

</> 
pub type VectorStoreFileCounts {
  VectorStoreFileCounts(
    in_progress: Int,
    completed: Int,
    failed: Int,
    cancelled: Int,
    total: Int,
  )
}

Constructors 

  • VectorStoreFileCounts(
  in_progress: Int,
  completed: Int,
  failed: Int,
  cancelled: Int,
  total: Int,
)

VectorStoreFileError

</> 
pub type VectorStoreFileError {
  VectorStoreFileError(
    code: VectorStoreFileErrorCode,
    message: String,
  )
}

Constructors

VectorStoreFileErrorCode

</> 
pub type VectorStoreFileErrorCode {
  ServerError
  UnsupportedFile
  InvalidFile
}

Constructors 

  • ServerError
  • UnsupportedFile
  • InvalidFile

VectorStoreFileObject

</> 
pub type VectorStoreFileObject {
  VectorStoreFileObject(
    id: String,
    object: String,
    usage_bytes: Int,
    created_at: Int,
    vector_store_id: String,
    status: VectorStoreFileStatus,
    last_error: option.Option(VectorStoreFileError),
    chunking_strategy: option.Option(ChunkingStrategyResponse),
    attributes: option.Option(dict.Dict(String, AttributeValue)),
  )
}

Constructors

VectorStoreFileStatus

</> 
pub type VectorStoreFileStatus {
  FileInProgress
  FileCompleted
  FileCancelled
  FileFailed
}

Constructors 

  • FileInProgress
  • FileCompleted
  • FileCancelled
  • FileFailed

VectorStoreObject

</> 
pub type VectorStoreObject {
  VectorStoreObject(
    id: String,
    object: String,
    created_at: Int,
    name: option.Option(String),
    usage_bytes: Int,
    file_counts: VectorStoreFileCounts,
    status: VectorStoreStatus,
    expires_after: option.Option(VectorStoreExpirationAfter),
    expires_at: option.Option(Int),
    last_active_at: option.Option(Int),
    metadata: option.Option(dict.Dict(String, String)),
  )
}

Constructors

VectorStoreSearchQuery

</>

Untagged: Text(String) or Array(List(String)).

pub type VectorStoreSearchQuery {
  TextQuery(query: String)
  ArrayQuery(queries: List(String))
}

Constructors 

  • TextQuery(query: String)
  • ArrayQuery(queries: List(String))

VectorStoreSearchRequest

</> 
pub type VectorStoreSearchRequest {
  VectorStoreSearchRequest(
    query: VectorStoreSearchQuery,
    rewrite_query: option.Option(Bool),
    max_num_results: option.Option(Int),
    filters: option.Option(Filter),
    ranking_options: option.Option(RankingOptions),
  )
}

Constructors

VectorStoreSearchResultContentObject

</> 
pub type VectorStoreSearchResultContentObject {
  VectorStoreSearchResultContentObject(
    content_type: String,
    text: String,
  )
}

Constructors 

  • VectorStoreSearchResultContentObject(
  content_type: String,
  text: String,
)

VectorStoreSearchResultItem

</> 
pub type VectorStoreSearchResultItem {
  VectorStoreSearchResultItem(
    file_id: String,
    filename: String,
    score: Float,
    attributes: dict.Dict(String, AttributeValue),
    content: List(VectorStoreSearchResultContentObject),
  )
}

Constructors

VectorStoreSearchResultsPage

</> 
pub type VectorStoreSearchResultsPage {
  VectorStoreSearchResultsPage(
    object: String,
    search_query: List(String),
    data: List(VectorStoreSearchResultItem),
    has_more: Bool,
    next_page: option.Option(String),
  )
}

Constructors

VectorStoreStatus

</> 
pub type VectorStoreStatus {
  StoreExpired
  StoreInProgress
  StoreCompleted
}

Constructors 

  • StoreExpired
  • StoreInProgress
  • StoreCompleted

Values

attribute_value_decoder

</> 
pub fn attribute_value_decoder() -> decode.Decoder(AttributeValue)

attribute_value_to_json

</> 
pub fn attribute_value_to_json(
  value: AttributeValue,
) -> json.Json

batch_cancel_request

</> 
pub fn batch_cancel_request(
  config: config.Config,
  vector_store_id: String,
  batch_id: String,
) -> request.Request(String)

batch_cancel_response

</> 
pub fn batch_cancel_response(
  response: response.Response(String),
) -> Result(VectorStoreFileBatchObject, error.GlopenaiError)

batch_create_request

</> 
pub fn batch_create_request(
  config: config.Config,
  vector_store_id: String,
  request: CreateVectorStoreFileBatchRequest,
) -> request.Request(String)

batch_create_response

</> 
pub fn batch_create_response(
  response: response.Response(String),
) -> Result(VectorStoreFileBatchObject, error.GlopenaiError)

batch_list_files_request

</> 
pub fn batch_list_files_request(
  config: config.Config,
  vector_store_id: String,
  batch_id: String,
) -> request.Request(String)

batch_list_files_request_with_query

</> 
pub fn batch_list_files_request_with_query(
  config: config.Config,
  vector_store_id: String,
  batch_id: String,
  query: ListFilesInVectorStoreBatchQuery,
) -> request.Request(String)

batch_list_files_response

</> 
pub fn batch_list_files_response(
  response: response.Response(String),
) -> Result(ListVectorStoreFilesResponse, error.GlopenaiError)

batch_retrieve_request

</> 
pub fn batch_retrieve_request(
  config: config.Config,
  vector_store_id: String,
  batch_id: String,
) -> request.Request(String)

batch_retrieve_response

</> 
pub fn batch_retrieve_response(
  response: response.Response(String),
) -> Result(VectorStoreFileBatchObject, error.GlopenaiError)

batch_with_attributes

</> 
pub fn batch_with_attributes(
  request: CreateVectorStoreFileBatchRequest,
  attributes: dict.Dict(String, AttributeValue),
) -> CreateVectorStoreFileBatchRequest

batch_with_chunking_strategy

</> 
pub fn batch_with_chunking_strategy(
  request: CreateVectorStoreFileBatchRequest,
  chunking_strategy: ChunkingStrategyRequestParam,
) -> CreateVectorStoreFileBatchRequest

batch_with_file_ids

</> 
pub fn batch_with_file_ids(
  request: CreateVectorStoreFileBatchRequest,
  file_ids: List(String),
) -> CreateVectorStoreFileBatchRequest

batch_with_files

</> 
pub fn batch_with_files(
  request: CreateVectorStoreFileBatchRequest,
  files: List(CreateVectorStoreFileRequest),
) -> CreateVectorStoreFileBatchRequest

chunking_strategy_request_param_decoder

</> 
pub fn chunking_strategy_request_param_decoder() -> decode.Decoder(
  ChunkingStrategyRequestParam,
)

chunking_strategy_request_param_to_json

</> 
pub fn chunking_strategy_request_param_to_json(
  strategy: ChunkingStrategyRequestParam,
) -> json.Json

chunking_strategy_response_decoder

</> 
pub fn chunking_strategy_response_decoder() -> decode.Decoder(
  ChunkingStrategyResponse,
)

chunking_strategy_response_to_json

</> 
pub fn chunking_strategy_response_to_json(
  strategy: ChunkingStrategyResponse,
) -> json.Json

comparison_type_decoder

</> 
pub fn comparison_type_decoder() -> decode.Decoder(ComparisonType)

comparison_type_to_json

</> 
pub fn comparison_type_to_json(
  comparison_type: ComparisonType,
) -> json.Json

compound_type_decoder

</> 
pub fn compound_type_decoder() -> decode.Decoder(CompoundType)

compound_type_to_json

</> 
pub fn compound_type_to_json(
  compound_type: CompoundType,
) -> json.Json

create_request

</> 
pub fn create_request(
  config: config.Config,
  request: CreateVectorStoreRequest,
) -> request.Request(String)

create_response

</> 
pub fn create_response(
  response: response.Response(String),
) -> Result(VectorStoreObject, error.GlopenaiError)

create_vector_store_file_batch_request_to_json

</> 
pub fn create_vector_store_file_batch_request_to_json(
  request: CreateVectorStoreFileBatchRequest,
) -> json.Json

create_vector_store_file_request_to_json

</> 
pub fn create_vector_store_file_request_to_json(
  request: CreateVectorStoreFileRequest,
) -> json.Json

create_vector_store_request_to_json

</> 
pub fn create_vector_store_request_to_json(
  request: CreateVectorStoreRequest,
) -> json.Json

delete_request

</> 
pub fn delete_request(
  config: config.Config,
  vector_store_id: String,
) -> request.Request(String)

delete_response

</> 
pub fn delete_response(
  response: response.Response(String),
) -> Result(DeleteVectorStoreResponse, error.GlopenaiError)

empty_list_files_in_vector_store_batch_query

</> 
pub fn empty_list_files_in_vector_store_batch_query() -> ListFilesInVectorStoreBatchQuery

empty_list_vector_store_files_query

</> 
pub fn empty_list_vector_store_files_query() -> ListVectorStoreFilesQuery

empty_list_vector_stores_query

</> 
pub fn empty_list_vector_stores_query() -> ListVectorStoresQuery

file_content_request

</> 
pub fn file_content_request(
  config: config.Config,
  vector_store_id: String,
  file_id: String,
) -> request.Request(String)

file_content_response

</> 
pub fn file_content_response(
  response: response.Response(String),
) -> Result(VectorStoreFileContentResponse, error.GlopenaiError)

file_create_request

</> 
pub fn file_create_request(
  config: config.Config,
  vector_store_id: String,
  request: CreateVectorStoreFileRequest,
) -> request.Request(String)

file_create_response

</> 
pub fn file_create_response(
  response: response.Response(String),
) -> Result(VectorStoreFileObject, error.GlopenaiError)

file_delete_request

</> 
pub fn file_delete_request(
  config: config.Config,
  vector_store_id: String,
  file_id: String,
) -> request.Request(String)

file_delete_response

</> 
pub fn file_delete_response(
  response: response.Response(String),
) -> Result(DeleteVectorStoreFileResponse, error.GlopenaiError)

file_list_request

</> 
pub fn file_list_request(
  config: config.Config,
  vector_store_id: String,
) -> request.Request(String)

file_list_request_with_query

</> 
pub fn file_list_request_with_query(
  config: config.Config,
  vector_store_id: String,
  query: ListVectorStoreFilesQuery,
) -> request.Request(String)

file_list_response

</> 
pub fn file_list_response(
  response: response.Response(String),
) -> Result(ListVectorStoreFilesResponse, error.GlopenaiError)

file_retrieve_request

</> 
pub fn file_retrieve_request(
  config: config.Config,
  vector_store_id: String,
  file_id: String,
) -> request.Request(String)

file_retrieve_response

</> 
pub fn file_retrieve_response(
  response: response.Response(String),
) -> Result(VectorStoreFileObject, error.GlopenaiError)

file_update_request

</> 
pub fn file_update_request(
  config: config.Config,
  vector_store_id: String,
  file_id: String,
  request: UpdateVectorStoreFileAttributesRequest,
) -> request.Request(String)

file_update_response

</> 
pub fn file_update_response(
  response: response.Response(String),
) -> Result(VectorStoreFileObject, error.GlopenaiError)

file_with_attributes

</> 
pub fn file_with_attributes(
  request: CreateVectorStoreFileRequest,
  attributes: dict.Dict(String, AttributeValue),
) -> CreateVectorStoreFileRequest

file_with_chunking_strategy

</> 
pub fn file_with_chunking_strategy(
  request: CreateVectorStoreFileRequest,
  chunking_strategy: ChunkingStrategyRequestParam,
) -> CreateVectorStoreFileRequest

filter_decoder

</> 
pub fn filter_decoder() -> decode.Decoder(Filter)

filter_to_json

</> 
pub fn filter_to_json(filter: Filter) -> json.Json

list_request

</> 
pub fn list_request(
  config: config.Config,
) -> request.Request(String)

list_request_with_query

</> 
pub fn list_request_with_query(
  config: config.Config,
  query: ListVectorStoresQuery,
) -> request.Request(String)

list_response

</> 
pub fn list_response(
  response: response.Response(String),
) -> Result(ListVectorStoresResponse, error.GlopenaiError)

new_create_file_batch_request

</> 
pub fn new_create_file_batch_request() -> CreateVectorStoreFileBatchRequest

new_create_file_request

</> 
pub fn new_create_file_request(
  file_id: String,
) -> CreateVectorStoreFileRequest

new_create_request

</> 
pub fn new_create_request() -> CreateVectorStoreRequest

new_search_request

</> 
pub fn new_search_request(
  query: VectorStoreSearchQuery,
) -> VectorStoreSearchRequest

new_update_request

</> 
pub fn new_update_request() -> UpdateVectorStoreRequest

ranker_decoder

</> 
pub fn ranker_decoder() -> decode.Decoder(Ranker)

ranker_to_json

</> 
pub fn ranker_to_json(ranker: Ranker) -> json.Json

ranking_options_decoder

</> 
pub fn ranking_options_decoder() -> decode.Decoder(RankingOptions)

ranking_options_to_json

</> 
pub fn ranking_options_to_json(
  options: RankingOptions,
) -> json.Json

retrieve_request

</> 
pub fn retrieve_request(
  config: config.Config,
  vector_store_id: String,
) -> request.Request(String)

retrieve_response

</> 
pub fn retrieve_response(
  response: response.Response(String),
) -> Result(VectorStoreObject, error.GlopenaiError)

search_request

</> 
pub fn search_request(
  config: config.Config,
  vector_store_id: String,
  request: VectorStoreSearchRequest,
) -> request.Request(String)

search_response

</> 
pub fn search_response(
  response: response.Response(String),
) -> Result(VectorStoreSearchResultsPage, error.GlopenaiError)

search_with_filters

</> 
pub fn search_with_filters(
  request: VectorStoreSearchRequest,
  filters: Filter,
) -> VectorStoreSearchRequest

search_with_max_num_results

</> 
pub fn search_with_max_num_results(
  request: VectorStoreSearchRequest,
  max_num_results: Int,
) -> VectorStoreSearchRequest

search_with_ranking_options

</> 
pub fn search_with_ranking_options(
  request: VectorStoreSearchRequest,
  ranking_options: RankingOptions,
) -> VectorStoreSearchRequest

search_with_rewrite_query

</> 
pub fn search_with_rewrite_query(
  request: VectorStoreSearchRequest,
  rewrite_query: Bool,
) -> VectorStoreSearchRequest

static_chunking_strategy_decoder

</> 
pub fn static_chunking_strategy_decoder() -> decode.Decoder(
  StaticChunkingStrategy,
)

static_chunking_strategy_to_json

</> 
pub fn static_chunking_strategy_to_json(
  strategy: StaticChunkingStrategy,
) -> json.Json

update_request

</> 
pub fn update_request(
  config: config.Config,
  vector_store_id: String,
  request: UpdateVectorStoreRequest,
) -> request.Request(String)

update_response

</> 
pub fn update_response(
  response: response.Response(String),
) -> Result(VectorStoreObject, error.GlopenaiError)

update_vector_store_file_attributes_request_to_json

</> 
pub fn update_vector_store_file_attributes_request_to_json(
  request: UpdateVectorStoreFileAttributesRequest,
) -> json.Json

update_vector_store_request_to_json

</> 
pub fn update_vector_store_request_to_json(
  request: UpdateVectorStoreRequest,
) -> json.Json

update_with_expires_after

</> 
pub fn update_with_expires_after(
  request: UpdateVectorStoreRequest,
  expires_after: VectorStoreExpirationAfter,
) -> UpdateVectorStoreRequest

update_with_metadata

</> 
pub fn update_with_metadata(
  request: UpdateVectorStoreRequest,
  metadata: dict.Dict(String, String),
) -> UpdateVectorStoreRequest

update_with_name

</> 
pub fn update_with_name(
  request: UpdateVectorStoreRequest,
  name: String,
) -> UpdateVectorStoreRequest

vector_store_expiration_after_decoder

</> 
pub fn vector_store_expiration_after_decoder() -> decode.Decoder(
  VectorStoreExpirationAfter,
)

vector_store_expiration_after_to_json

</> 
pub fn vector_store_expiration_after_to_json(
  expiration: VectorStoreExpirationAfter,
) -> json.Json

vector_store_file_attributes_decoder

</> 
pub fn vector_store_file_attributes_decoder() -> decode.Decoder(
  dict.Dict(String, AttributeValue),
)

vector_store_file_attributes_to_json

</> 
pub fn vector_store_file_attributes_to_json(
  attributes: dict.Dict(String, AttributeValue),
) -> json.Json

vector_store_file_batch_status_decoder

</> 
pub fn vector_store_file_batch_status_decoder() -> decode.Decoder(
  VectorStoreFileBatchStatus,
)

vector_store_file_counts_decoder

</> 
pub fn vector_store_file_counts_decoder() -> decode.Decoder(
  VectorStoreFileCounts,
)

vector_store_file_counts_to_json

</> 
pub fn vector_store_file_counts_to_json(
  counts: VectorStoreFileCounts,
) -> json.Json

vector_store_file_error_code_decoder

</> 
pub fn vector_store_file_error_code_decoder() -> decode.Decoder(
  VectorStoreFileErrorCode,
)

vector_store_file_object_decoder

</> 
pub fn vector_store_file_object_decoder() -> decode.Decoder(
  VectorStoreFileObject,
)

vector_store_file_status_decoder

</> 
pub fn vector_store_file_status_decoder() -> decode.Decoder(
  VectorStoreFileStatus,
)

vector_store_file_status_to_json

</> 
pub fn vector_store_file_status_to_json(
  status: VectorStoreFileStatus,
) -> json.Json

vector_store_object_decoder

</> 
pub fn vector_store_object_decoder() -> decode.Decoder(
  VectorStoreObject,
)

vector_store_search_query_to_json

</> 
pub fn vector_store_search_query_to_json(
  query: VectorStoreSearchQuery,
) -> json.Json

vector_store_search_request_to_json

</> 
pub fn vector_store_search_request_to_json(
  request: VectorStoreSearchRequest,
) -> json.Json

vector_store_status_decoder

</> 
pub fn vector_store_status_decoder() -> decode.Decoder(
  VectorStoreStatus,
)

vector_store_status_to_json

</> 
pub fn vector_store_status_to_json(
  status: VectorStoreStatus,
) -> json.Json

with_chunking_strategy

</> 
pub fn with_chunking_strategy(
  request: CreateVectorStoreRequest,
  chunking_strategy: ChunkingStrategyRequestParam,
) -> CreateVectorStoreRequest

with_description

</> 
pub fn with_description(
  request: CreateVectorStoreRequest,
  description: String,
) -> CreateVectorStoreRequest

with_expires_after

</> 
pub fn with_expires_after(
  request: CreateVectorStoreRequest,
  expires_after: VectorStoreExpirationAfter,
) -> CreateVectorStoreRequest

with_file_ids

</> 
pub fn with_file_ids(
  request: CreateVectorStoreRequest,
  file_ids: List(String),
) -> CreateVectorStoreRequest

with_metadata

</> 
pub fn with_metadata(
  request: CreateVectorStoreRequest,
  metadata: dict.Dict(String, String),
) -> CreateVectorStoreRequest

with_name

</> 
pub fn with_name(
  request: CreateVectorStoreRequest,
  name: String,
) -> CreateVectorStoreRequest
✨ Search Document