pipelinedocument.go

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

package llamacloud

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"slices"

	"github.com/run-llama/llama-parse-go/internal/apijson"
	"github.com/run-llama/llama-parse-go/internal/apiquery"
	shimjson "github.com/run-llama/llama-parse-go/internal/encoding/json"
	"github.com/run-llama/llama-parse-go/internal/requestconfig"
	"github.com/run-llama/llama-parse-go/option"
	"github.com/run-llama/llama-parse-go/packages/pagination"
	"github.com/run-llama/llama-parse-go/packages/param"
	"github.com/run-llama/llama-parse-go/packages/respjson"
)

// PipelineDocumentService contains methods and other services that help with
// interacting with the llama-cloud API.
//
// Note, unlike clients, this service does not read variables from the environment
// automatically. You should not instantiate this service directly, and instead use
// the [NewPipelineDocumentService] method instead.
type PipelineDocumentService struct {
	options []option.RequestOption
}

// NewPipelineDocumentService generates a new service that applies the given
// options to each request. These options are applied after the parent client's
// options (if there is one), and before any request-specific options.
func NewPipelineDocumentService(opts ...option.RequestOption) (r PipelineDocumentService) {
	r = PipelineDocumentService{}
	r.options = opts
	return
}

// Batch create documents for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) New(ctx context.Context, pipelineID string, params PipelineDocumentNewParams, opts ...option.RequestOption) (res *[]CloudDocument, err error) {
	opts = slices.Concat(r.options, opts)
	if pipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents", pipelineID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	return res, err
}

// Return a list of documents for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) List(ctx context.Context, pipelineID string, query PipelineDocumentListParams, opts ...option.RequestOption) (res *pagination.PaginatedCloudDocuments[CloudDocument], err error) {
	var raw *http.Response
	opts = slices.Concat(r.options, opts)
	opts = append([]option.RequestOption{option.WithResponseInto(&raw)}, opts...)
	if pipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/paginated", pipelineID)
	cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, query, &res, opts...)
	if err != nil {
		return nil, err
	}
	err = cfg.Execute()
	if err != nil {
		return nil, err
	}
	res.SetPageConfig(cfg, raw)
	return res, nil
}

// Return a list of documents for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) ListAutoPaging(ctx context.Context, pipelineID string, query PipelineDocumentListParams, opts ...option.RequestOption) *pagination.PaginatedCloudDocumentsAutoPager[CloudDocument] {
	return pagination.NewPaginatedCloudDocumentsAutoPager(r.List(ctx, pipelineID, query, opts...))
}

// Delete a document from a pipeline; runs async (vectors first, then MongoDB
// record).
//
// Deprecated: deprecated
func (r *PipelineDocumentService) Delete(ctx context.Context, documentID string, params PipelineDocumentDeleteParams, opts ...option.RequestOption) (err error) {
	opts = slices.Concat(r.options, opts)
	opts = append([]option.RequestOption{option.WithHeader("Accept", "*/*")}, opts...)
	if params.PipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return err
	}
	if documentID == "" {
		err = errors.New("missing required document_id parameter")
		return err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/%s", params.PipelineID, url.PathEscape(documentID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, params, nil, opts...)
	return err
}

// Return a single document for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) Get(ctx context.Context, documentID string, params PipelineDocumentGetParams, opts ...option.RequestOption) (res *CloudDocument, err error) {
	opts = slices.Concat(r.options, opts)
	if params.PipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	if documentID == "" {
		err = errors.New("missing required document_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/%s", params.PipelineID, url.PathEscape(documentID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, params, &res, opts...)
	return res, err
}

// Return a list of chunks for a pipeline document.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) GetChunks(ctx context.Context, documentID string, params PipelineDocumentGetChunksParams, opts ...option.RequestOption) (res *[]TextNode, err error) {
	opts = slices.Concat(r.options, opts)
	if params.PipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	if documentID == "" {
		err = errors.New("missing required document_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/%s/chunks", params.PipelineID, url.PathEscape(documentID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, params, &res, opts...)
	return res, err
}

// Return a single document for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) GetStatus(ctx context.Context, documentID string, params PipelineDocumentGetStatusParams, opts ...option.RequestOption) (res *ManagedIngestionStatusResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if params.PipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	if documentID == "" {
		err = errors.New("missing required document_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/%s/status", params.PipelineID, url.PathEscape(documentID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, params, &res, opts...)
	return res, err
}

// Count the documents in a pipeline, grouped by ingestion status.
//
// Counts reflect each document's last recorded status rather than a freshly
// computed one, so a document that changed status in the last few moments may
// still be counted under its previous one. Use
// `GET /pipelines/{pipeline_id}/documents/{document_id}/status` when a single
// document's status has to be up to the moment.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) GetStatusCounts(ctx context.Context, pipelineID string, query PipelineDocumentGetStatusCountsParams, opts ...option.RequestOption) (res *PipelineDocumentGetStatusCountsResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if pipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/status-counts", pipelineID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, query, &res, opts...)
	return res, err
}

// Sync a specific document for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) Sync(ctx context.Context, documentID string, params PipelineDocumentSyncParams, opts ...option.RequestOption) (res *PipelineDocumentSyncResponse, err error) {
	opts = slices.Concat(r.options, opts)
	if params.PipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	if documentID == "" {
		err = errors.New("missing required document_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents/%s/sync", params.PipelineID, url.PathEscape(documentID))
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, params, &res, opts...)
	return res, err
}

// Batch create or update a document for a pipeline.
//
// Deprecated: deprecated
func (r *PipelineDocumentService) Upsert(ctx context.Context, pipelineID string, params PipelineDocumentUpsertParams, opts ...option.RequestOption) (res *[]CloudDocument, err error) {
	opts = slices.Concat(r.options, opts)
	if pipelineID == "" {
		err = errors.New("missing required pipeline_id parameter")
		return nil, err
	}
	path := fmt.Sprintf("api/v1/pipelines/%s/documents", pipelineID)
	err = requestconfig.ExecuteNewRequest(ctx, http.MethodPut, path, params, &res, opts...)
	return res, err
}

// Cloud document stored in S3.
type CloudDocument struct {
	ID                        string         `json:"id" api:"required"`
	Metadata                  map[string]any `json:"metadata" api:"required"`
	Text                      string         `json:"text" api:"required"`
	ExcludedEmbedMetadataKeys []string       `json:"excluded_embed_metadata_keys"`
	ExcludedLlmMetadataKeys   []string       `json:"excluded_llm_metadata_keys"`
	// indices in the CloudDocument.text where a new page begins. e.g. Second page
	// starts at index specified by page_positions[1].
	PagePositions  []int64        `json:"page_positions" api:"nullable"`
	StatusMetadata map[string]any `json:"status_metadata" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                        respjson.Field
		Metadata                  respjson.Field
		Text                      respjson.Field
		ExcludedEmbedMetadataKeys respjson.Field
		ExcludedLlmMetadataKeys   respjson.Field
		PagePositions             respjson.Field
		StatusMetadata            respjson.Field
		ExtraFields               map[string]respjson.Field
		raw                       string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r CloudDocument) RawJSON() string { return r.JSON.raw }
func (r *CloudDocument) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Create a new cloud document.
//
// The properties Metadata, Text are required.
type CloudDocumentCreateParam struct {
	Metadata map[string]any    `json:"metadata,omitzero" api:"required"`
	Text     string            `json:"text" api:"required"`
	ID       param.Opt[string] `json:"id,omitzero"`
	// indices in the CloudDocument.text where a new page begins. e.g. Second page
	// starts at index specified by page_positions[1].
	PagePositions             []int64  `json:"page_positions,omitzero"`
	ExcludedEmbedMetadataKeys []string `json:"excluded_embed_metadata_keys,omitzero"`
	ExcludedLlmMetadataKeys   []string `json:"excluded_llm_metadata_keys,omitzero"`
	paramObj
}

func (r CloudDocumentCreateParam) MarshalJSON() (data []byte, err error) {
	type shadow CloudDocumentCreateParam
	return param.MarshalObject(r, (*shadow)(&r))
}
func (r *CloudDocumentCreateParam) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Provided for backward compatibility.
type TextNode struct {
	ClassName string `json:"class_name"`
	// Embedding of the node.
	Embedding []float64 `json:"embedding" api:"nullable"`
	// End char index of the node.
	EndCharIdx int64 `json:"end_char_idx" api:"nullable"`
	// Metadata keys that are excluded from text for the embed model.
	ExcludedEmbedMetadataKeys []string `json:"excluded_embed_metadata_keys"`
	// Metadata keys that are excluded from text for the LLM.
	ExcludedLlmMetadataKeys []string `json:"excluded_llm_metadata_keys"`
	// A flat dictionary of metadata fields
	ExtraInfo map[string]any `json:"extra_info"`
	// Unique ID of the node.
	ID string `json:"id_"`
	// Separator between metadata fields when converting to string.
	MetadataSeperator string `json:"metadata_seperator"`
	// Template for how metadata is formatted, with {key} and {value} placeholders.
	MetadataTemplate string `json:"metadata_template"`
	// MIME type of the node content.
	Mimetype string `json:"mimetype"`
	// A mapping of relationships to other node information.
	Relationships map[string]TextNodeRelationshipUnion `json:"relationships"`
	// Start char index of the node.
	StartCharIdx int64 `json:"start_char_idx" api:"nullable"`
	// Text content of the node.
	Text string `json:"text"`
	// Template for how text is formatted, with {content} and {metadata_str}
	// placeholders.
	TextTemplate string `json:"text_template"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ClassName                 respjson.Field
		Embedding                 respjson.Field
		EndCharIdx                respjson.Field
		ExcludedEmbedMetadataKeys respjson.Field
		ExcludedLlmMetadataKeys   respjson.Field
		ExtraInfo                 respjson.Field
		ID                        respjson.Field
		MetadataSeperator         respjson.Field
		MetadataTemplate          respjson.Field
		Mimetype                  respjson.Field
		Relationships             respjson.Field
		StartCharIdx              respjson.Field
		Text                      respjson.Field
		TextTemplate              respjson.Field
		ExtraFields               map[string]respjson.Field
		raw                       string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r TextNode) RawJSON() string { return r.JSON.raw }
func (r *TextNode) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// TextNodeRelationshipUnion contains all possible properties and values from
// [TextNodeRelationshipRelatedNodeInfo], [[]TextNodeRelationshipArrayItem].
//
// Use the methods beginning with 'As' to cast the union to one of its variants.
//
// If the underlying value is not a json object, one of the following properties
// will be valid: OfTextNodeRelationshipArray]
type TextNodeRelationshipUnion struct {
	// This field will be present if the value is a [[]TextNodeRelationshipArrayItem]
	// instead of an object.
	OfTextNodeRelationshipArray []TextNodeRelationshipArrayItem `json:",inline"`
	// This field is from variant [TextNodeRelationshipRelatedNodeInfo].
	NodeID string `json:"node_id"`
	// This field is from variant [TextNodeRelationshipRelatedNodeInfo].
	ClassName string `json:"class_name"`
	// This field is from variant [TextNodeRelationshipRelatedNodeInfo].
	Hash string `json:"hash"`
	// This field is from variant [TextNodeRelationshipRelatedNodeInfo].
	Metadata map[string]any `json:"metadata"`
	// This field is from variant [TextNodeRelationshipRelatedNodeInfo].
	NodeType string `json:"node_type"`
	JSON     struct {
		OfTextNodeRelationshipArray respjson.Field
		NodeID                      respjson.Field
		ClassName                   respjson.Field
		Hash                        respjson.Field
		Metadata                    respjson.Field
		NodeType                    respjson.Field
		raw                         string
	} `json:"-"`
}

func (u TextNodeRelationshipUnion) AsRelatedNodeInfo() (v TextNodeRelationshipRelatedNodeInfo) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

func (u TextNodeRelationshipUnion) AsTextNodeRelationshipArray() (v []TextNodeRelationshipArrayItem) {
	apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
	return
}

// Returns the unmodified JSON received from the API
func (u TextNodeRelationshipUnion) RawJSON() string { return u.JSON.raw }

func (r *TextNodeRelationshipUnion) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type TextNodeRelationshipRelatedNodeInfo struct {
	NodeID    string         `json:"node_id" api:"required"`
	ClassName string         `json:"class_name"`
	Hash      string         `json:"hash" api:"nullable"`
	Metadata  map[string]any `json:"metadata"`
	NodeType  string         `json:"node_type" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		NodeID      respjson.Field
		ClassName   respjson.Field
		Hash        respjson.Field
		Metadata    respjson.Field
		NodeType    respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r TextNodeRelationshipRelatedNodeInfo) RawJSON() string { return r.JSON.raw }
func (r *TextNodeRelationshipRelatedNodeInfo) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type TextNodeRelationshipArrayItem struct {
	NodeID    string         `json:"node_id" api:"required"`
	ClassName string         `json:"class_name"`
	Hash      string         `json:"hash" api:"nullable"`
	Metadata  map[string]any `json:"metadata"`
	NodeType  string         `json:"node_type" api:"nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		NodeID      respjson.Field
		ClassName   respjson.Field
		Hash        respjson.Field
		Metadata    respjson.Field
		NodeType    respjson.Field
		ExtraFields map[string]respjson.Field
		raw         string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r TextNodeRelationshipArrayItem) RawJSON() string { return r.JSON.raw }
func (r *TextNodeRelationshipArrayItem) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// Counts of the documents in a pipeline, grouped by ingestion status.
type PipelineDocumentGetStatusCountsResponse struct {
	// Number of documents per ingestion status; every status is present.
	Counts map[string]int64 `json:"counts" api:"required"`
	// ID of the pipeline the documents belong to.
	PipelineID string `json:"pipeline_id" api:"required" format:"uuid"`
	// Total number of documents counted.
	TotalCount int64 `json:"total_count" api:"required"`
	// Data source the counts were restricted to.
	DataSourceID string `json:"data_source_id" api:"nullable" format:"uuid"`
	// File the counts were restricted to.
	FileID string `json:"file_id" api:"nullable" format:"uuid"`
	// Whether only directly uploaded documents were counted.
	OnlyDirectUpload bool `json:"only_direct_upload"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Counts           respjson.Field
		PipelineID       respjson.Field
		TotalCount       respjson.Field
		DataSourceID     respjson.Field
		FileID           respjson.Field
		OnlyDirectUpload respjson.Field
		ExtraFields      map[string]respjson.Field
		raw              string
	} `json:"-"`
}

// Returns the unmodified JSON received from the API
func (r PipelineDocumentGetStatusCountsResponse) RawJSON() string { return r.JSON.raw }
func (r *PipelineDocumentGetStatusCountsResponse) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

type PipelineDocumentSyncResponse = any

type PipelineDocumentNewParams struct {
	Body      []CloudDocumentCreateParam
	ProjectID param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

func (r PipelineDocumentNewParams) MarshalJSON() (data []byte, err error) {
	return shimjson.Marshal(r.Body)
}
func (r *PipelineDocumentNewParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// URLQuery serializes [PipelineDocumentNewParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentNewParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentListParams struct {
	FileID                     param.Opt[string] `query:"file_id,omitzero" format:"uuid" json:"-"`
	OnlyAPIDataSourceDocuments param.Opt[bool]   `query:"only_api_data_source_documents,omitzero" json:"-"`
	OnlyDirectUpload           param.Opt[bool]   `query:"only_direct_upload,omitzero" json:"-"`
	ProjectID                  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	Limit                      param.Opt[int64]  `query:"limit,omitzero" json:"-"`
	Skip                       param.Opt[int64]  `query:"skip,omitzero" json:"-"`
	// Any of "cached", "ttl".
	StatusRefreshPolicy PipelineDocumentListParamsStatusRefreshPolicy `query:"status_refresh_policy,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentListParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentListParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentListParamsStatusRefreshPolicy string

const (
	PipelineDocumentListParamsStatusRefreshPolicyCached PipelineDocumentListParamsStatusRefreshPolicy = "cached"
	PipelineDocumentListParamsStatusRefreshPolicyTtl    PipelineDocumentListParamsStatusRefreshPolicy = "ttl"
)

type PipelineDocumentDeleteParams struct {
	PipelineID string            `path:"pipeline_id" api:"required" format:"uuid" json:"-"`
	ProjectID  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentDeleteParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentDeleteParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentGetParams struct {
	PipelineID string            `path:"pipeline_id" api:"required" format:"uuid" json:"-"`
	ProjectID  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentGetParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentGetParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentGetChunksParams struct {
	PipelineID string            `path:"pipeline_id" api:"required" format:"uuid" json:"-"`
	ProjectID  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentGetChunksParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentGetChunksParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentGetStatusParams struct {
	PipelineID string            `path:"pipeline_id" api:"required" format:"uuid" json:"-"`
	ProjectID  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentGetStatusParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentGetStatusParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentGetStatusCountsParams struct {
	DataSourceID     param.Opt[string] `query:"data_source_id,omitzero" format:"uuid" json:"-"`
	FileID           param.Opt[string] `query:"file_id,omitzero" format:"uuid" json:"-"`
	ProjectID        param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	OnlyDirectUpload param.Opt[bool]   `query:"only_direct_upload,omitzero" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentGetStatusCountsParams]'s query parameters
// as `url.Values`.
func (r PipelineDocumentGetStatusCountsParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentSyncParams struct {
	PipelineID string            `path:"pipeline_id" api:"required" format:"uuid" json:"-"`
	ProjectID  param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

// URLQuery serializes [PipelineDocumentSyncParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentSyncParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}

type PipelineDocumentUpsertParams struct {
	Body      []CloudDocumentCreateParam
	ProjectID param.Opt[string] `query:"project_id,omitzero" format:"uuid" json:"-"`
	paramObj
}

func (r PipelineDocumentUpsertParams) MarshalJSON() (data []byte, err error) {
	return shimjson.Marshal(r.Body)
}
func (r *PipelineDocumentUpsertParams) UnmarshalJSON(data []byte) error {
	return apijson.UnmarshalRoot(data, r)
}

// URLQuery serializes [PipelineDocumentUpsertParams]'s query parameters as
// `url.Values`.
func (r PipelineDocumentUpsertParams) URLQuery() (v url.Values, err error) {
	return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
		NestedFormat: apiquery.NestedQueryFormatBrackets,
	})
}