// Code generated by @openmeter/typespec-typescript. DO NOT EDIT.

import { type Client, http } from '../core.js'
import { type Result, type RequestOptions } from '../lib/types.js'
import { request } from '../lib/request.js'
import { toURLSearchParams, encodeSort } from '../lib/encodings.js'
import {
  toWire,
  toPathWire,
  fromWire,
  assertValid,
  toSnakeCase,
} from '../lib/wire.js'
import * as schemas from '../models/schemas.js'
import type {
  ListInvoicesRequest,
  ListInvoicesResponse,
  GetInvoiceRequest,
  GetInvoiceResponse,
  UpdateInvoiceRequest,
  UpdateInvoiceResponse,
  DeleteInvoiceRequest,
  DeleteInvoiceResponse,
  AdvanceInvoiceRequest,
  AdvanceInvoiceResponse,
  ApproveInvoiceRequest,
  ApproveInvoiceResponse,
  RetryInvoiceRequest,
  RetryInvoiceResponse,
  SnapshotQuantitiesInvoiceRequest,
  SnapshotQuantitiesInvoiceResponse,
} from '../models/operations/invoices.js'

/**
 * List billing invoices
 *
 * List billing invoices.
 *
 * Returns a page of invoices. Gathering invoices are never included. Use `filter`
 * to narrow by status, customer, dates, or service period start. Use `sort` to
 * control ordering.
 *
 * GET /openmeter/billing/invoices
 */
export function listInvoices(
  client: Client,
  req: ListInvoicesRequest = {},
  options?: RequestOptions,
): Promise<Result<ListInvoicesResponse>> {
  return request(() => {
    if (client._options.validate && req.sort !== undefined) {
      assertValid(schemas.listInvoicesQueryParams.shape.sort, req.sort)
    }
    const query = toWire(
      {
        page: req.page,
        sort: encodeSort(req.sort, toSnakeCase),
        filter: req.filter,
      },
      schemas.listInvoicesQueryParams,
    )
    if (client._options.validate) {
      assertValid(schemas.listInvoicesQueryParamsWire, query)
    }
    const searchParams = toURLSearchParams(query)
    return http(client)
      .get('openmeter/billing/invoices', { ...options, searchParams })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.listInvoicesResponseWire, data)
        }
        return fromWire(data, schemas.listInvoicesResponse)
      })
  })
}

/**
 * Get a billing invoice
 *
 * Get a billing invoice by ID.
 *
 * Returns the full invoice resource including line items, status details, totals,
 * and workflow configuration snapshot.
 *
 * GET /openmeter/billing/invoices/{invoiceId}
 */
export function getInvoice(
  client: Client,
  req: GetInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<GetInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.getInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.getInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}`
    return http(client)
      .get(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.getInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.getInvoiceResponse)
      })
  })
}

/**
 * Update a billing invoice
 *
 * Update a billing invoice.
 *
 * Only the mutable fields of the invoice can be edited: description, labels,
 * supplier, customer, workflow settings, and top-level lines. Top-level lines are
 * matched by `id`; lines without an `id` are created, and existing lines omitted
 * from `lines` are deleted. Detailed (child) lines are always computed and cannot
 * be edited directly. Only invoices in draft status can be updated.
 *
 * PUT /openmeter/billing/invoices/{invoiceId}
 */
export function updateInvoice(
  client: Client,
  req: UpdateInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<UpdateInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.updateInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.updateInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}`
    const body = toWire(req.body, schemas.updateInvoiceBody)
    if (client._options.validate) {
      assertValid(schemas.updateInvoiceBodyWire, body)
    }
    return http(client)
      .put(path, { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.updateInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.updateInvoiceResponse)
      })
  })
}

/**
 * Delete a billing invoice
 *
 * Delete a billing invoice.
 *
 * Only standard invoices in draft status can be deleted. Deleting an invoice will
 * also delete all associated line items and workflow configuration.
 *
 * DELETE /openmeter/billing/invoices/{invoiceId}
 */
export function deleteInvoice(
  client: Client,
  req: DeleteInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<DeleteInvoiceResponse>> {
  return request(async () => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.deleteInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.deleteInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}`
    await http(client).delete(path, options)
  })
}

/**
 * Advance billing invoice's next status
 *
 * Advance a billing invoice.
 *
 * Advances the invoice to the next workflow state. The next state is determined by
 * the invoice's current status and workflow configuration. Only invoices in draft
 * or issued status can be advanced.
 *
 * POST /openmeter/billing/invoices/{invoiceId}/advance
 */
export function advanceInvoice(
  client: Client,
  req: AdvanceInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<AdvanceInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.advanceInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.advanceInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}/advance`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.advanceInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.advanceInvoiceResponse)
      })
  })
}

/**
 * Send the invoice to the customer
 *
 * Approve a billing invoice.
 *
 * This call instantly sends the invoice to the customer using the configured
 * billing profile app.
 *
 * This call is valid in two invoice statuses:
 *
 * - draft: the invoice will be sent to the customer, the invoice state becomes
 * issued
 * - manual_approval_needed: the invoice will be sent to the customer, the invoice
 * state becomes issued
 *
 * POST /openmeter/billing/invoices/{invoiceId}/approve
 */
export function approveInvoice(
  client: Client,
  req: ApproveInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<ApproveInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.approveInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.approveInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}/approve`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.approveInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.approveInvoiceResponse)
      })
  })
}

/**
 * Retry advancing the invoice after a failed attempt
 *
 * Retry sending a billing invoice.
 *
 * Retry advancing the invoice after a failed attempt.
 *
 * The action can be called when the invoice's statusDetails' actions field contain
 * the "retry" action.
 *
 * POST /openmeter/billing/invoices/{invoiceId}/retry
 */
export function retryInvoice(
  client: Client,
  req: RetryInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<RetryInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.retryInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.retryInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}/retry`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.retryInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.retryInvoiceResponse)
      })
  })
}

/**
 * Snapshot quantities for usage based line items
 *
 * Snapshot quantities for usage-based line items.
 *
 * This call will snapshot the quantities for all usage based line items in the
 * invoice.
 *
 * This call is only valid in draft.waiting_for_collection status, where the
 * collection period can be skipped using this action.
 *
 * POST /openmeter/billing/invoices/{invoiceId}/snapshot-quantities
 */
export function snapshotQuantitiesInvoice(
  client: Client,
  req: SnapshotQuantitiesInvoiceRequest,
  options?: RequestOptions,
): Promise<Result<SnapshotQuantitiesInvoiceResponse>> {
  return request(() => {
    const pathParamsInput = {
      invoiceId: req.invoiceId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.snapshotQuantitiesInvoicePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.snapshotQuantitiesInvoicePathParamsWire, pathParams)
    }
    const path = `openmeter/billing/invoices/${(() => {
      if (pathParams.invoiceId === undefined) {
        throw new Error('missing path parameter: invoiceId')
      }
      return encodeURIComponent(String(pathParams.invoiceId))
    })()}/snapshot-quantities`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.snapshotQuantitiesInvoiceResponseWire, data)
        }
        return fromWire(data, schemas.snapshotQuantitiesInvoiceResponse)
      })
  })
}