api/spec/packages/aip-client-javascript/src/funcs/features.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 {
  ListFeaturesRequest,
  ListFeaturesResponse,
  CreateFeatureRequest,
  CreateFeatureResponse,
  GetFeatureRequest,
  GetFeatureResponse,
  UpdateFeatureRequest,
  UpdateFeatureResponse,
  DeleteFeatureRequest,
  DeleteFeatureResponse,
  QueryFeatureCostRequest,
  QueryFeatureCostResponse,
} from '../models/operations/features.js'

/**
 * List features
 *
 * List all features.
 *
 * GET /openmeter/features
 */
export function listFeatures(
  client: Client,
  req: ListFeaturesRequest = {},
  options?: RequestOptions,
): Promise<Result<ListFeaturesResponse>> {
  return request(() => {
    if (client._options.validate && req.sort !== undefined) {
      assertValid(schemas.listFeaturesQueryParams.shape.sort, req.sort)
    }
    const query = toWire(
      {
        page: req.page,
        sort: encodeSort(req.sort, toSnakeCase),
        filter: req.filter,
      },
      schemas.listFeaturesQueryParams,
    )
    if (client._options.validate) {
      assertValid(schemas.listFeaturesQueryParamsWire, query)
    }
    const searchParams = toURLSearchParams(query)
    return http(client)
      .get('openmeter/features', { ...options, searchParams })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.listFeaturesResponseWire, data)
        }
        return fromWire(data, schemas.listFeaturesResponse)
      })
  })
}

/**
 * Create feature
 *
 * Create a feature.
 *
 * POST /openmeter/features
 */
export function createFeature(
  client: Client,
  req: CreateFeatureRequest,
  options?: RequestOptions,
): Promise<Result<CreateFeatureResponse>> {
  return request(() => {
    const body = toWire(req, schemas.createFeatureBody)
    if (client._options.validate) {
      assertValid(schemas.createFeatureBodyWire, body)
    }
    return http(client)
      .post('openmeter/features', { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.createFeatureResponseWire, data)
        }
        return fromWire(data, schemas.createFeatureResponse)
      })
  })
}

/**
 * Get feature
 *
 * Get a feature by id.
 *
 * GET /openmeter/features/{featureId}
 */
export function getFeature(
  client: Client,
  req: GetFeatureRequest,
  options?: RequestOptions,
): Promise<Result<GetFeatureResponse>> {
  return request(() => {
    const pathParamsInput = {
      featureId: req.featureId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.getFeaturePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.getFeaturePathParamsWire, pathParams)
    }
    const path = `openmeter/features/${(() => {
      if (pathParams.featureId === undefined) {
        throw new Error('missing path parameter: featureId')
      }
      return encodeURIComponent(String(pathParams.featureId))
    })()}`
    return http(client)
      .get(path, options)
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.getFeatureResponseWire, data)
        }
        return fromWire(data, schemas.getFeatureResponse)
      })
  })
}

/**
 * Update feature
 *
 * Update a feature by id. Currently only the unit_cost field can be updated.
 *
 * PATCH /openmeter/features/{featureId}
 */
export function updateFeature(
  client: Client,
  req: UpdateFeatureRequest,
  options?: RequestOptions,
): Promise<Result<UpdateFeatureResponse>> {
  return request(() => {
    const pathParamsInput = {
      featureId: req.featureId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.updateFeaturePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.updateFeaturePathParamsWire, pathParams)
    }
    const path = `openmeter/features/${(() => {
      if (pathParams.featureId === undefined) {
        throw new Error('missing path parameter: featureId')
      }
      return encodeURIComponent(String(pathParams.featureId))
    })()}`
    const body = toWire(req.body, schemas.updateFeatureBody)
    if (client._options.validate) {
      assertValid(schemas.updateFeatureBodyWire, body)
    }
    return http(client)
      .patch(path, { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.updateFeatureResponseWire, data)
        }
        return fromWire(data, schemas.updateFeatureResponse)
      })
  })
}

/**
 * Delete feature
 *
 * Delete a feature by id.
 *
 * DELETE /openmeter/features/{featureId}
 */
export function deleteFeature(
  client: Client,
  req: DeleteFeatureRequest,
  options?: RequestOptions,
): Promise<Result<DeleteFeatureResponse>> {
  return request(async () => {
    const pathParamsInput = {
      featureId: req.featureId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.deleteFeaturePathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.deleteFeaturePathParamsWire, pathParams)
    }
    const path = `openmeter/features/${(() => {
      if (pathParams.featureId === undefined) {
        throw new Error('missing path parameter: featureId')
      }
      return encodeURIComponent(String(pathParams.featureId))
    })()}`
    await http(client).delete(path, options)
  })
}

/**
 * Query feature cost
 *
 * Query the cost of a feature.
 *
 * POST /openmeter/features/{featureId}/cost/query
 */
export function queryFeatureCost(
  client: Client,
  req: QueryFeatureCostRequest,
  options?: RequestOptions,
): Promise<Result<QueryFeatureCostResponse>> {
  return request(() => {
    const pathParamsInput = {
      featureId: req.featureId,
    }
    const pathParams = client._options.validate
      ? toPathWire(pathParamsInput, schemas.queryFeatureCostPathParams)
      : pathParamsInput
    if (client._options.validate) {
      assertValid(schemas.queryFeatureCostPathParamsWire, pathParams)
    }
    const path = `openmeter/features/${(() => {
      if (pathParams.featureId === undefined) {
        throw new Error('missing path parameter: featureId')
      }
      return encodeURIComponent(String(pathParams.featureId))
    })()}/cost/query`
    const body = toWire(req.body, schemas.queryFeatureCostBody)
    if (client._options.validate) {
      assertValid(schemas.queryFeatureCostBodyWire, body)
    }
    return http(client)
      .post(path, { ...options, json: body })
      .json()
      .then((data) => {
        if (client._options.validate) {
          assertValid(schemas.queryFeatureCostResponseWire, data)
        }
        return fromWire(data, schemas.queryFeatureCostResponse)
      })
  })
}