api/spec/packages/aip-client-javascript/src/funcs/addons.ts

// 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 {
  ListAddonsRequest,
  ListAddonsResponse,
  CreateAddonRequest,
  CreateAddonResponse,
  UpdateAddonRequest,
  UpdateAddonResponse,
  GetAddonRequest,
  GetAddonResponse,
  DeleteAddonRequest,
  DeleteAddonResponse,
  ArchiveAddonRequest,
  ArchiveAddonResponse,
  PublishAddonRequest,
  PublishAddonResponse,
} from '../models/operations/addons.js'

/**
 * List add-ons
 *
 * List all add-ons.
 *
 * GET /openmeter/addons
 */
export function listAddons(
  client: Client,
  req: ListAddonsRequest = {},
  options?: RequestOptions,
): Promise<Result<ListAddonsResponse>> {
  return request(() => {
    if (client._options.validate && req.sort !== undefined) {
      assertValid(schemas.listAddonsQueryParams.shape.sort, req.sort)
    }
    const query = toWire(
      {
        page: req.page,
        sort: encodeSort(req.sort, toSnakeCase),
        filter: req.filter,
      },
      schemas.listAddonsQueryParams,
    )
    if (client._options.validate) {
      assertValid(schemas.listAddonsQueryParamsWire, query)
    }
    const searchParams = toURLSearchParams(query)
    return http(client)
      .get('openmeter/addons', { ...options, searchParams })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.listAddonsResponseWire, data)
        }
        return fromWire(data, schemas.listAddonsResponse)
      })
  })
}

/**
 * Create add-on
 *
 * Create a new add-on.
 *
 * POST /openmeter/addons
 */
export function createAddon(
  client: Client,
  req: CreateAddonRequest,
  options?: RequestOptions,
): Promise<Result<CreateAddonResponse>> {
  return request(() => {
    const body = toWire(req, schemas.createAddonBody)
    if (client._options.validate) {
      assertValid(schemas.createAddonBodyWire, body)
    }
    return http(client)
      .post('openmeter/addons', { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.createAddonResponseWire, data)
        }
        return fromWire(data, schemas.createAddonResponse)
      })
  })
}

/**
 * Update add-on
 *
 * Update an add-on by id.
 *
 * PUT /openmeter/addons/{addonId}
 */
export function updateAddon(
  client: Client,
  req: UpdateAddonRequest,
  options?: RequestOptions,
): Promise<Result<UpdateAddonResponse>> {
  return request(() => {
    const pathParamsInput = {
      addonId: req.addonId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.updateAddonPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.updateAddonPathParamsWire, pathParams)
    }
    const path = `openmeter/addons/${(() => {
      if (pathParams.addonId === undefined) {
        throw new Error('missing path parameter: addonId')
      }
      return encodeURIComponent(String(pathParams.addonId))
    })()}`
    const body = toWire(req.body, schemas.updateAddonBody)
    if (client._options.validate) {
      assertValid(schemas.updateAddonBodyWire, body)
    }
    return http(client)
      .put(path, { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.updateAddonResponseWire, data)
        }
        return fromWire(data, schemas.updateAddonResponse)
      })
  })
}

/**
 * Get add-on
 *
 * Get add-on by id.
 *
 * GET /openmeter/addons/{addonId}
 */
export function getAddon(
  client: Client,
  req: GetAddonRequest,
  options?: RequestOptions,
): Promise<Result<GetAddonResponse>> {
  return request(() => {
    const pathParamsInput = {
      addonId: req.addonId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.getAddonPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.getAddonPathParamsWire, pathParams)
    }
    const path = `openmeter/addons/${(() => {
      if (pathParams.addonId === undefined) {
        throw new Error('missing path parameter: addonId')
      }
      return encodeURIComponent(String(pathParams.addonId))
    })()}`
    return http(client)
      .get(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.getAddonResponseWire, data)
        }
        return fromWire(data, schemas.getAddonResponse)
      })
  })
}

/**
 * Soft delete add-on
 *
 * Soft delete add-on by id.
 *
 * DELETE /openmeter/addons/{addonId}
 */
export function deleteAddon(
  client: Client,
  req: DeleteAddonRequest,
  options?: RequestOptions,
): Promise<Result<DeleteAddonResponse>> {
  return request(async () => {
    const pathParamsInput = {
      addonId: req.addonId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.deleteAddonPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.deleteAddonPathParamsWire, pathParams)
    }
    const path = `openmeter/addons/${(() => {
      if (pathParams.addonId === undefined) {
        throw new Error('missing path parameter: addonId')
      }
      return encodeURIComponent(String(pathParams.addonId))
    })()}`
    await http(client).delete(path, options)
  })
}

/**
 * Archive add-on version
 *
 * Archive an add-on version.
 *
 * POST /openmeter/addons/{addonId}/archive
 */
export function archiveAddon(
  client: Client,
  req: ArchiveAddonRequest,
  options?: RequestOptions,
): Promise<Result<ArchiveAddonResponse>> {
  return request(() => {
    const pathParamsInput = {
      addonId: req.addonId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.archiveAddonPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.archiveAddonPathParamsWire, pathParams)
    }
    const path = `openmeter/addons/${(() => {
      if (pathParams.addonId === undefined) {
        throw new Error('missing path parameter: addonId')
      }
      return encodeURIComponent(String(pathParams.addonId))
    })()}/archive`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.archiveAddonResponseWire, data)
        }
        return fromWire(data, schemas.archiveAddonResponse)
      })
  })
}

/**
 * Publish add-on version
 *
 * Publish an add-on version.
 *
 * POST /openmeter/addons/{addonId}/publish
 */
export function publishAddon(
  client: Client,
  req: PublishAddonRequest,
  options?: RequestOptions,
): Promise<Result<PublishAddonResponse>> {
  return request(() => {
    const pathParamsInput = {
      addonId: req.addonId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.publishAddonPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.publishAddonPathParamsWire, pathParams)
    }
    const path = `openmeter/addons/${(() => {
      if (pathParams.addonId === undefined) {
        throw new Error('missing path parameter: addonId')
      }
      return encodeURIComponent(String(pathParams.addonId))
    })()}/publish`
    return http(client)
      .post(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.publishAddonResponseWire, data)
        }
        return fromWire(data, schemas.publishAddonResponse)
      })
  })
}