@yugabytedb/perf-advisor-client 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @yugabytedb/perf-advisor-client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+TypeScript client for the Perf Advisor v2 API (`/api/v2`), generated with
+[orval](https://orval.dev) from the public spec: a typed request function and a
+react-query (v3) hook for every operation, and the spec's types.
+
+```ts
+import Axios from 'axios';
+import { listUniverses, setPerfAdvisorAxios, useListUniverses } from '@yugabytedb/perf-advisor-client';
+
+setPerfAdvisorAxios(
+  Axios.create({ baseURL: 'https://pa.example.com/api/v2', headers: { 'X-AUTH-TP-API-TOKEN': token } }),
+);
+const page = await listUniverses({ paging: { limit: 20, need_total_count: true } });
+```
+
+Requests go through the axios instance set with `setPerfAdvisorAxios` (by default `/api/v2` on the
+current origin), so its interceptors and auth headers apply. `axios`, `react`, `react-dom` and
+`react-query` are peer dependencies.
+
+## Building and publishing
+
+The package is built by the backend Gradle build and versioned with Perf Advisor:
+
+```sh
+cd backend
+./gradlew :clients:typescript:packClient
+npm publish clients/typescript/build/package --access public --tag latest
+```
+
+Publish from a release branch, after Jenkins has built that version, with Yugabyte npm
+credentials. The version is the Perf Advisor version (`1.7.0-b5`), which npm treats as a
+prerelease, hence `--tag latest`.

package/dist/generated/api/anomaly/anomaly.d.ts

@@ -0,0 +1,228 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { Anomaly } from '../../model/anomaly';
+import type { AnomalyDetection } from '../../model/anomalyDetection';
+import type { AnomalyGroup } from '../../model/anomalyGroup';
+import type { AnomalyGroupPagedResp } from '../../model/anomalyGroupPagedResp';
+import type { AnomalyGroupsOfType } from '../../model/anomalyGroupsOfType';
+import type { AnomalyPagedResp } from '../../model/anomalyPagedResp';
+import type { AnomalyType } from '../../model/anomalyType';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { GetAnomalyGroupParams } from '../../model/getAnomalyGroupParams';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListAnomaliesParams } from '../../model/listAnomaliesParams';
+import type { ListAnomalyGroupsByTypeParams } from '../../model/listAnomalyGroupsByTypeParams';
+import type { ListAnomalyGroupsParams } from '../../model/listAnomalyGroupsParams';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the universe's anomalies and insights that were active in the time window - by
+ * default the 24 hours before `end_time`. Ordered by `sort_by`, `START_TIME` by default,
+ * descending by default.
+ * @summary List anomalies
+ */
+export declare const listAnomalies: (universeId: string, params?: ListAnomaliesParams, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyPagedResp>;
+export declare const getListAnomaliesQueryKey: (universeId: string, params?: ListAnomaliesParams) => readonly [`/universes/${string}/anomalies`, ...ListAnomaliesParams[]];
+export declare const getListAnomaliesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: Anomaly[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListAnomaliesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: Anomaly[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: Anomaly[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListAnomaliesQueryResult = NonNullable<Awaited<ReturnType<typeof listAnomalies>>>;
+export type ListAnomaliesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List anomalies
+ */
+export declare function useListAnomalies<TData = Awaited<ReturnType<typeof listAnomalies>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListAnomaliesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAnomalies>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns one anomaly of the universe.
+ * @summary Get an anomaly
+ */
+export declare const getAnomaly: (universeId: string, anomalyId: string, options?: SecondParameter<typeof paRequest>) => Promise<Anomaly>;
+export declare const getGetAnomalyQueryKey: (universeId: string, anomalyId: string) => readonly [`/universes/${string}/anomalies/${string}`];
+export declare const getGetAnomalyQueryOptions: <TData = Anomaly, TError = import("../../model").Error>(universeId: string, anomalyId: string, options?: {
+    query?: UseQueryOptions<Anomaly, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<Anomaly, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetAnomalyQueryResult = NonNullable<Awaited<ReturnType<typeof getAnomaly>>>;
+export type GetAnomalyQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get an anomaly
+ */
+export declare function useGetAnomaly<TData = Awaited<ReturnType<typeof getAnomaly>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, anomalyId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAnomaly>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists the kinds of anomalies Perf Advisor detects, with their graphs and troubleshooting
+ * guidelines. The same for every universe; served per universe so that YBA and YBM tokens
+ * can read it.
+ * @summary List anomaly types
+ */
+export declare const listAnomalyTypes: (universeId: string, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyType[]>;
+export declare const getListAnomalyTypesQueryKey: (universeId: string) => readonly [`/universes/${string}/anomaly-types`];
+export declare const getListAnomalyTypesQueryOptions: <TData = AnomalyType[], TError = import("../../model").Error>(universeId: string, options?: {
+    query?: UseQueryOptions<AnomalyType[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<AnomalyType[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListAnomalyTypesQueryResult = NonNullable<Awaited<ReturnType<typeof listAnomalyTypes>>>;
+export type ListAnomalyTypesQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List anomaly types
+ */
+export declare function useListAnomalyTypes<TData = Awaited<ReturnType<typeof listAnomalyTypes>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAnomalyTypes>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists the anomalies active in the time window - by default the 24 hours before
+ * `end_time` - grouped by type and entity. Ordered by severity, most severe first by
+ * default (`direction` `DESC`).
+ * @summary List anomaly groups
+ */
+export declare const listAnomalyGroups: (universeId: string, params?: ListAnomalyGroupsParams, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyGroupPagedResp>;
+export declare const getListAnomalyGroupsQueryKey: (universeId: string, params?: ListAnomalyGroupsParams) => readonly [`/universes/${string}/anomaly-groups`, ...ListAnomalyGroupsParams[]];
+export declare const getListAnomalyGroupsQueryOptions: <TData = import("../../model").Pagination & {
+    entities: AnomalyGroup[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListAnomalyGroupsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: AnomalyGroup[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: AnomalyGroup[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListAnomalyGroupsQueryResult = NonNullable<Awaited<ReturnType<typeof listAnomalyGroups>>>;
+export type ListAnomalyGroupsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List anomaly groups
+ */
+export declare function useListAnomalyGroups<TData = Awaited<ReturnType<typeof listAnomalyGroups>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListAnomalyGroupsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAnomalyGroups>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns one anomaly group, with the anomalies active in the time window - by default the 24
+ * hours before `end_time`.
+ * @summary Get an anomaly group
+ */
+export declare const getAnomalyGroup: (universeId: string, anomalyGroupId: string, params?: GetAnomalyGroupParams, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyGroup>;
+export declare const getGetAnomalyGroupQueryKey: (universeId: string, anomalyGroupId: string, params?: GetAnomalyGroupParams) => readonly [`/universes/${string}/anomaly-groups/${string}`, ...GetAnomalyGroupParams[]];
+export declare const getGetAnomalyGroupQueryOptions: <TData = AnomalyGroup, TError = import("../../model").Error>(universeId: string, anomalyGroupId: string, params?: GetAnomalyGroupParams, options?: {
+    query?: UseQueryOptions<AnomalyGroup, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<AnomalyGroup, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetAnomalyGroupQueryResult = NonNullable<Awaited<ReturnType<typeof getAnomalyGroup>>>;
+export type GetAnomalyGroupQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get an anomaly group
+ */
+export declare function useGetAnomalyGroup<TData = Awaited<ReturnType<typeof getAnomalyGroup>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, anomalyGroupId: string, params?: GetAnomalyGroupParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAnomalyGroup>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * For each anomaly type, or each of `anomaly_type` when set, returns its most severe groups
+ * in the time window - by default the 24 hours before `end_time` - and how many there are.
+ * Every type is returned; one without anomalies in the window has a `total_count` of 0 and
+ * no groups. Ordered by category, then type, as the anomaly types list them.
+ * @summary List the top anomaly groups of each type
+ */
+export declare const listAnomalyGroupsByType: (universeId: string, params?: ListAnomalyGroupsByTypeParams, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyGroupsOfType[]>;
+export declare const getListAnomalyGroupsByTypeQueryKey: (universeId: string, params?: ListAnomalyGroupsByTypeParams) => readonly [`/universes/${string}/anomaly-groups-by-type`, ...ListAnomalyGroupsByTypeParams[]];
+export declare const getListAnomalyGroupsByTypeQueryOptions: <TData = AnomalyGroupsOfType[], TError = import("../../model").Error>(universeId: string, params?: ListAnomalyGroupsByTypeParams, options?: {
+    query?: UseQueryOptions<AnomalyGroupsOfType[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<AnomalyGroupsOfType[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListAnomalyGroupsByTypeQueryResult = NonNullable<Awaited<ReturnType<typeof listAnomalyGroupsByType>>>;
+export type ListAnomalyGroupsByTypeQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List the top anomaly groups of each type
+ */
+export declare function useListAnomalyGroupsByType<TData = Awaited<ReturnType<typeof listAnomalyGroupsByType>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListAnomalyGroupsByTypeParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listAnomalyGroupsByType>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns the state of the latest on-demand anomaly detection run of the universe.
+ * @summary Get on-demand anomaly detection state
+ */
+export declare const getAnomalyDetection: (universeId: string, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyDetection>;
+export declare const getGetAnomalyDetectionQueryKey: (universeId: string) => readonly [`/universes/${string}/anomaly-detection`];
+export declare const getGetAnomalyDetectionQueryOptions: <TData = AnomalyDetection, TError = import("../../model").Error>(universeId: string, options?: {
+    query?: UseQueryOptions<AnomalyDetection, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<AnomalyDetection, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetAnomalyDetectionQueryResult = NonNullable<Awaited<ReturnType<typeof getAnomalyDetection>>>;
+export type GetAnomalyDetectionQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get on-demand anomaly detection state
+ */
+export declare function useGetAnomalyDetection<TData = Awaited<ReturnType<typeof getAnomalyDetection>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getAnomalyDetection>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Starts detecting anomalies of the universe right away rather than on the next scheduled
+ * run. When a run is already scheduled or in progress, returns it instead of starting
+ * another. Progress is in `info.state`.
+ * @summary Start anomaly detection
+ */
+export declare const startAnomalyDetection: (universeId: string, options?: SecondParameter<typeof paRequest>) => Promise<AnomalyDetection>;
+export declare const getStartAnomalyDetectionMutationKey: () => readonly ["startAnomalyDetection"];
+export declare const getStartAnomalyDetectionMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<AnomalyDetection, TError, StartAnomalyDetectionMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<AnomalyDetection, TError, StartAnomalyDetectionMutationVariables, TContext>;
+export type StartAnomalyDetectionMutationResult = NonNullable<Awaited<ReturnType<typeof startAnomalyDetection>>>;
+export type StartAnomalyDetectionMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type StartAnomalyDetectionMutationVariables = {
+    universeId: string;
+};
+/**
+* @summary Start anomaly detection
+*/
+export declare const useStartAnomalyDetection: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<AnomalyDetection, TError, StartAnomalyDetectionMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<AnomalyDetection, TError, StartAnomalyDetectionMutationVariables, TContext>;
+export {};

package/dist/generated/api/customer/customer.d.ts

@@ -0,0 +1,200 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { Customer } from '../../model/customer';
+import type { CustomerPagedResp } from '../../model/customerPagedResp';
+import type { CustomerSpec } from '../../model/customerSpec';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListCustomerRuntimeConfigsParams } from '../../model/listCustomerRuntimeConfigsParams';
+import type { ListCustomersParams } from '../../model/listCustomersParams';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { RuntimeConfig } from '../../model/runtimeConfig';
+import type { RuntimeConfigSpec } from '../../model/runtimeConfigSpec';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
+type WritableKeys<T> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, P>;
+}[keyof T];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type DistributeReadOnlyOverUnions<T> = T extends any ? NonReadonly<T> : never;
+type Writable<T> = Pick<T, WritableKeys<T>>;
+type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
+    [P in keyof Writable<T>]: T[P] extends object ? NonReadonly<NonNullable<T[P]>> : T[P];
+} : DistributeReadOnlyOverUnions<T>;
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the customers registered with Perf Advisor. Ordered by UUID, ascending by default.
+ * @summary List customers
+ */
+export declare const listCustomers: (params?: ListCustomersParams, options?: SecondParameter<typeof paRequest>) => Promise<CustomerPagedResp>;
+export declare const getListCustomersQueryKey: (params?: ListCustomersParams) => readonly ["/customers", ...ListCustomersParams[]];
+export declare const getListCustomersQueryOptions: <TData = import("../../model").Pagination & {
+    entities: Customer[];
+}, TError = import("../../model").Error>(params?: ListCustomersParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: Customer[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: Customer[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListCustomersQueryResult = NonNullable<Awaited<ReturnType<typeof listCustomers>>>;
+export type ListCustomersQueryError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List customers
+ */
+export declare function useListCustomers<TData = Awaited<ReturnType<typeof listCustomers>>, TError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse>(params?: ListCustomersParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listCustomers>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns a registered customer.
+ * @summary Get a customer
+ */
+export declare const getCustomer: (customerId: string, options?: SecondParameter<typeof paRequest>) => Promise<Customer>;
+export declare const getGetCustomerQueryKey: (customerId: string) => readonly [`/customers/${string}`];
+export declare const getGetCustomerQueryOptions: <TData = Customer, TError = import("../../model").Error>(customerId: string, options?: {
+    query?: UseQueryOptions<Customer, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<Customer, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetCustomerQueryResult = NonNullable<Awaited<ReturnType<typeof getCustomer>>>;
+export type GetCustomerQueryError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get a customer
+ */
+export declare function useGetCustomer<TData = Awaited<ReturnType<typeof getCustomer>>, TError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse>(customerId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getCustomer>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Registers the customer with Perf Advisor, or replaces the spec of a customer already
+ * registered. YBA and YBM call this before registering the customer's universes.
+ * @summary Register or update a customer
+ */
+export declare const registerCustomer: (customerId: string, customerSpec: NonReadonly<CustomerSpec>, options?: SecondParameter<typeof paRequest>) => Promise<Customer>;
+export declare const getRegisterCustomerMutationKey: () => readonly ["registerCustomer"];
+export declare const getRegisterCustomerMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Customer, TError, RegisterCustomerMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<Customer, TError, RegisterCustomerMutationVariables, TContext>;
+export type RegisterCustomerMutationResult = NonNullable<Awaited<ReturnType<typeof registerCustomer>>>;
+export type RegisterCustomerMutationBody = NonReadonly<CustomerSpec>;
+export type RegisterCustomerMutationError = BadRequestResponse | UnauthorizedResponse | ConflictResponse | InternalErrorResponse;
+export type RegisterCustomerMutationVariables = {
+    customerId: string;
+    data: NonReadonly<CustomerSpec>;
+};
+/**
+* @summary Register or update a customer
+*/
+export declare const useRegisterCustomer: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Customer, TError, RegisterCustomerMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<Customer, TError, RegisterCustomerMutationVariables, TContext>;
+/**
+* Removes the customer's registration.
+* @summary Delete a customer
+*/
+export declare const deleteCustomer: (customerId: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteCustomerMutationKey: () => readonly ["deleteCustomer"];
+export declare const getDeleteCustomerMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteCustomerMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteCustomerMutationVariables, TContext>;
+export type DeleteCustomerMutationResult = NonNullable<Awaited<ReturnType<typeof deleteCustomer>>>;
+export type DeleteCustomerMutationError = UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteCustomerMutationVariables = {
+    customerId: string;
+};
+/**
+* @summary Delete a customer
+*/
+export declare const useDeleteCustomer: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteCustomerMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteCustomerMutationVariables, TContext>;
+/**
+* Lists the runtime configuration effective for a customer. Ordered by key.
+* @summary List for a customer runtime configuration
+*/
+export declare const listCustomerRuntimeConfigs: (customerId: string, params?: ListCustomerRuntimeConfigsParams, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig[]>;
+export declare const getListCustomerRuntimeConfigsQueryKey: (customerId: string, params?: ListCustomerRuntimeConfigsParams) => readonly [`/customers/${string}/runtime-configs`, ...ListCustomerRuntimeConfigsParams[]];
+export declare const getListCustomerRuntimeConfigsQueryOptions: <TData = RuntimeConfig[], TError = import("../../model").Error>(customerId: string, params?: ListCustomerRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListCustomerRuntimeConfigsQueryResult = NonNullable<Awaited<ReturnType<typeof listCustomerRuntimeConfigs>>>;
+export type ListCustomerRuntimeConfigsQueryError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List for a customer runtime configuration
+ */
+export declare function useListCustomerRuntimeConfigs<TData = Awaited<ReturnType<typeof listCustomerRuntimeConfigs>>, TError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse>(customerId: string, params?: ListCustomerRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listCustomerRuntimeConfigs>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Sets the value of the key for a customer.
+ * @summary Set a runtime configuration value for a customer
+ */
+export declare const setCustomerRuntimeConfig: (customerId: string, key: string, runtimeConfigSpec: RuntimeConfigSpec, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig>;
+export declare const getSetCustomerRuntimeConfigMutationKey: () => readonly ["setCustomerRuntimeConfig"];
+export declare const getSetCustomerRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetCustomerRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<RuntimeConfig, TError, SetCustomerRuntimeConfigMutationVariables, TContext>;
+export type SetCustomerRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof setCustomerRuntimeConfig>>>;
+export type SetCustomerRuntimeConfigMutationBody = RuntimeConfigSpec;
+export type SetCustomerRuntimeConfigMutationError = BadRequestResponse | UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type SetCustomerRuntimeConfigMutationVariables = {
+    customerId: string;
+    key: string;
+    data: RuntimeConfigSpec;
+};
+/**
+* @summary Set a runtime configuration value for a customer
+*/
+export declare const useSetCustomerRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetCustomerRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<RuntimeConfig, TError, SetCustomerRuntimeConfigMutationVariables, TContext>;
+/**
+* Removes the value set for a customer, so the inherited value or the default applies again.
+* @summary Remove a runtime configuration value for a customer
+*/
+export declare const deleteCustomerRuntimeConfig: (customerId: string, key: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteCustomerRuntimeConfigMutationKey: () => readonly ["deleteCustomerRuntimeConfig"];
+export declare const getDeleteCustomerRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteCustomerRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteCustomerRuntimeConfigMutationVariables, TContext>;
+export type DeleteCustomerRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof deleteCustomerRuntimeConfig>>>;
+export type DeleteCustomerRuntimeConfigMutationError = UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteCustomerRuntimeConfigMutationVariables = {
+    customerId: string;
+    key: string;
+};
+/**
+* @summary Remove a runtime configuration value for a customer
+*/
+export declare const useDeleteCustomerRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteCustomerRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteCustomerRuntimeConfigMutationVariables, TContext>;
+export {};

package/dist/generated/api/export-config/export-config.d.ts

@@ -0,0 +1,175 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { ExportConfig } from '../../model/exportConfig';
+import type { ExportConfigPagedResp } from '../../model/exportConfigPagedResp';
+import type { ExportConfigSpec } from '../../model/exportConfigSpec';
+import type { ExportConfigValidation } from '../../model/exportConfigValidation';
+import type { ExportConfigValidationSpec } from '../../model/exportConfigValidationSpec';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListExportConfigsParams } from '../../model/listExportConfigsParams';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
+type WritableKeys<T> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, P>;
+}[keyof T];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type DistributeReadOnlyOverUnions<T> = T extends any ? NonReadonly<T> : never;
+type Writable<T> = Pick<T, WritableKeys<T>>;
+type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
+    [P in keyof Writable<T>]: T[P] extends object ? NonReadonly<NonNullable<T[P]>> : T[P];
+} : DistributeReadOnlyOverUnions<T>;
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the export configurations. Ordered by name, ascending by default.
+ * @summary List export configurations
+ */
+export declare const listExportConfigs: (params?: ListExportConfigsParams, options?: SecondParameter<typeof paRequest>) => Promise<ExportConfigPagedResp>;
+export declare const getListExportConfigsQueryKey: (params?: ListExportConfigsParams) => readonly ["/export-configs", ...ListExportConfigsParams[]];
+export declare const getListExportConfigsQueryOptions: <TData = import("../../model").Pagination & {
+    entities: ExportConfig[];
+}, TError = import("../../model").Error>(params?: ListExportConfigsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: ExportConfig[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: ExportConfig[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListExportConfigsQueryResult = NonNullable<Awaited<ReturnType<typeof listExportConfigs>>>;
+export type ListExportConfigsQueryError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List export configurations
+ */
+export declare function useListExportConfigs<TData = Awaited<ReturnType<typeof listExportConfigs>>, TError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse>(params?: ListExportConfigsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listExportConfigs>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Creates an export configuration after checking it, including that its endpoints are
+ * reachable. Perf Advisor assigns the UUID.
+ * @summary Create an export configuration
+ */
+export declare const createExportConfig: (exportConfigSpec: NonReadonly<ExportConfigSpec>, options?: SecondParameter<typeof paRequest>) => Promise<ExportConfig>;
+export declare const getCreateExportConfigMutationKey: () => readonly ["createExportConfig"];
+export declare const getCreateExportConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfig, TError, CreateExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<ExportConfig, TError, CreateExportConfigMutationVariables, TContext>;
+export type CreateExportConfigMutationResult = NonNullable<Awaited<ReturnType<typeof createExportConfig>>>;
+export type CreateExportConfigMutationBody = NonReadonly<ExportConfigSpec>;
+export type CreateExportConfigMutationError = BadRequestResponse | UnauthorizedResponse | ConflictResponse | InternalErrorResponse;
+export type CreateExportConfigMutationVariables = {
+    data: NonReadonly<ExportConfigSpec>;
+};
+/**
+* @summary Create an export configuration
+*/
+export declare const useCreateExportConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfig, TError, CreateExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<ExportConfig, TError, CreateExportConfigMutationVariables, TContext>;
+/**
+* Returns an export configuration.
+* @summary Get an export configuration
+*/
+export declare const getExportConfig: (exportConfigId: string, options?: SecondParameter<typeof paRequest>) => Promise<ExportConfig>;
+export declare const getGetExportConfigQueryKey: (exportConfigId: string) => readonly [`/export-configs/${string}`];
+export declare const getGetExportConfigQueryOptions: <TData = ExportConfig, TError = import("../../model").Error>(exportConfigId: string, options?: {
+    query?: UseQueryOptions<ExportConfig, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<ExportConfig, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetExportConfigQueryResult = NonNullable<Awaited<ReturnType<typeof getExportConfig>>>;
+export type GetExportConfigQueryError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get an export configuration
+ */
+export declare function useGetExportConfig<TData = Awaited<ReturnType<typeof getExportConfig>>, TError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse>(exportConfigId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getExportConfig>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Replaces the spec of an export configuration after checking it.
+ * @summary Edit an export configuration
+ */
+export declare const editExportConfig: (exportConfigId: string, exportConfigSpec: NonReadonly<ExportConfigSpec>, options?: SecondParameter<typeof paRequest>) => Promise<ExportConfig>;
+export declare const getEditExportConfigMutationKey: () => readonly ["editExportConfig"];
+export declare const getEditExportConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfig, TError, EditExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<ExportConfig, TError, EditExportConfigMutationVariables, TContext>;
+export type EditExportConfigMutationResult = NonNullable<Awaited<ReturnType<typeof editExportConfig>>>;
+export type EditExportConfigMutationBody = NonReadonly<ExportConfigSpec>;
+export type EditExportConfigMutationError = BadRequestResponse | UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type EditExportConfigMutationVariables = {
+    exportConfigId: string;
+    data: NonReadonly<ExportConfigSpec>;
+};
+/**
+* @summary Edit an export configuration
+*/
+export declare const useEditExportConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfig, TError, EditExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<ExportConfig, TError, EditExportConfigMutationVariables, TContext>;
+/**
+* Deletes an export configuration that no universe uses.
+* @summary Delete an export configuration
+*/
+export declare const deleteExportConfig: (exportConfigId: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteExportConfigMutationKey: () => readonly ["deleteExportConfig"];
+export declare const getDeleteExportConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteExportConfigMutationVariables, TContext>;
+export type DeleteExportConfigMutationResult = NonNullable<Awaited<ReturnType<typeof deleteExportConfig>>>;
+export type DeleteExportConfigMutationError = BadRequestResponse | UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteExportConfigMutationVariables = {
+    exportConfigId: string;
+};
+/**
+* @summary Delete an export configuration
+*/
+export declare const useDeleteExportConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteExportConfigMutationVariables, TContext>;
+/**
+* Checks an export configuration without saving it, including whether its endpoints are
+* reachable.
+* @summary Check an export configuration
+*/
+export declare const validateExportConfig: (exportConfigValidationSpec: NonReadonly<ExportConfigValidationSpec>, options?: SecondParameter<typeof paRequest>) => Promise<ExportConfigValidation>;
+export declare const getValidateExportConfigMutationKey: () => readonly ["validateExportConfig"];
+export declare const getValidateExportConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfigValidation, TError, ValidateExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<ExportConfigValidation, TError, ValidateExportConfigMutationVariables, TContext>;
+export type ValidateExportConfigMutationResult = NonNullable<Awaited<ReturnType<typeof validateExportConfig>>>;
+export type ValidateExportConfigMutationBody = NonReadonly<ExportConfigValidationSpec>;
+export type ValidateExportConfigMutationError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse;
+export type ValidateExportConfigMutationVariables = {
+    data: NonReadonly<ExportConfigValidationSpec>;
+};
+/**
+* @summary Check an export configuration
+*/
+export declare const useValidateExportConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<ExportConfigValidation, TError, ValidateExportConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<ExportConfigValidation, TError, ValidateExportConfigMutationVariables, TContext>;
+export {};