// Code generated by Fern. DO NOT EDIT.

package annotationqueues

import (
    core "pentagi/pkg/observability/langfuse/api/core"
    internal "pentagi/pkg/observability/langfuse/api/internal"
    context "context"
    api "pentagi/pkg/observability/langfuse/api"
    option "pentagi/pkg/observability/langfuse/api/option"
)


type Client struct {
    WithRawResponse *RawClient

    options *core.RequestOptions
    baseURL string
    caller *internal.Caller
}

func NewClient(options *core.RequestOptions) *Client {
    return &Client{
        WithRawResponse: NewRawClient(options),
        options: options,
        baseURL: options.BaseURL,
        caller: internal.NewCaller(
            &internal.CallerParams{
                Client: options.HTTPClient,
                MaxAttempts: options.MaxAttempts,
            },
        ),
    }
}

// Get all annotation queues
func (c *Client) Listqueues(
    ctx context.Context,
    request *api.AnnotationQueuesListQueuesRequest,
    opts ...option.RequestOption,
) (*api.PaginatedAnnotationQueues, error){
    response, err := c.WithRawResponse.Listqueues(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Create an annotation queue
func (c *Client) Createqueue(
    ctx context.Context,
    request *api.CreateAnnotationQueueRequest,
    opts ...option.RequestOption,
) (*api.AnnotationQueue, error){
    response, err := c.WithRawResponse.Createqueue(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Get an annotation queue by ID
func (c *Client) Getqueue(
    ctx context.Context,
    request *api.AnnotationQueuesGetQueueRequest,
    opts ...option.RequestOption,
) (*api.AnnotationQueue, error){
    response, err := c.WithRawResponse.Getqueue(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Get items for a specific annotation queue
func (c *Client) Listqueueitems(
    ctx context.Context,
    request *api.AnnotationQueuesListQueueItemsRequest,
    opts ...option.RequestOption,
) (*api.PaginatedAnnotationQueueItems, error){
    response, err := c.WithRawResponse.Listqueueitems(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Add an item to an annotation queue
func (c *Client) Createqueueitem(
    ctx context.Context,
    request *api.CreateAnnotationQueueItemRequest,
    opts ...option.RequestOption,
) (*api.AnnotationQueueItem, error){
    response, err := c.WithRawResponse.Createqueueitem(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Get a specific item from an annotation queue
func (c *Client) Getqueueitem(
    ctx context.Context,
    request *api.AnnotationQueuesGetQueueItemRequest,
    opts ...option.RequestOption,
) (*api.AnnotationQueueItem, error){
    response, err := c.WithRawResponse.Getqueueitem(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Remove an item from an annotation queue
func (c *Client) Deletequeueitem(
    ctx context.Context,
    request *api.AnnotationQueuesDeleteQueueItemRequest,
    opts ...option.RequestOption,
) (*api.DeleteAnnotationQueueItemResponse, error){
    response, err := c.WithRawResponse.Deletequeueitem(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Update an annotation queue item
func (c *Client) Updatequeueitem(
    ctx context.Context,
    request *api.UpdateAnnotationQueueItemRequest,
    opts ...option.RequestOption,
) (*api.AnnotationQueueItem, error){
    response, err := c.WithRawResponse.Updatequeueitem(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Create an assignment for a user to an annotation queue
func (c *Client) Createqueueassignment(
    ctx context.Context,
    request *api.AnnotationQueuesCreateQueueAssignmentRequest,
    opts ...option.RequestOption,
) (*api.CreateAnnotationQueueAssignmentResponse, error){
    response, err := c.WithRawResponse.Createqueueassignment(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

// Delete an assignment for a user to an annotation queue
func (c *Client) Deletequeueassignment(
    ctx context.Context,
    request *api.AnnotationQueuesDeleteQueueAssignmentRequest,
    opts ...option.RequestOption,
) (*api.DeleteAnnotationQueueAssignmentResponse, error){
    response, err := c.WithRawResponse.Deletequeueassignment(
        ctx,
        request,
        opts...,
    )
    if err != nil {
        return nil, err
    }
    return response.Body, nil
}

