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

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

@@ -0,0 +1,267 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { DeleteUniverseParams } from '../../model/deleteUniverseParams';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListUniverseNodesParams } from '../../model/listUniverseNodesParams';
+import type { ListUniverseRuntimeConfigsParams } from '../../model/listUniverseRuntimeConfigsParams';
+import type { ListUniversesParams } from '../../model/listUniversesParams';
+import type { MetadataRefresh } from '../../model/metadataRefresh';
+import type { MetadataRefreshSpec } from '../../model/metadataRefreshSpec';
+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 type { Universe } from '../../model/universe';
+import type { UniverseNodePagedResp } from '../../model/universeNodePagedResp';
+import type { UniversePagedResp } from '../../model/universePagedResp';
+import type { UniverseSpec } from '../../model/universeSpec';
+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 universes registered with Perf Advisor, including ones it has collected no data
+ * for yet. Ordered by `sort_by`, `NAME` (case-insensitive) by default, ascending by default.
+ * @summary List universes
+ */
+export declare const listUniverses: (params?: ListUniversesParams, options?: SecondParameter<typeof paRequest>) => Promise<UniversePagedResp>;
+export declare const getListUniversesQueryKey: (params?: ListUniversesParams) => readonly ["/universes", ...ListUniversesParams[]];
+export declare const getListUniversesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: Universe[];
+}, TError = import("../../model").Error>(params?: ListUniversesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: Universe[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: Universe[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListUniversesQueryResult = NonNullable<Awaited<ReturnType<typeof listUniverses>>>;
+export type ListUniversesQueryError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List universes
+ */
+export declare function useListUniverses<TData = Awaited<ReturnType<typeof listUniverses>>, TError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse>(params?: ListUniversesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listUniverses>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns a registered universe.
+ * @summary Get a universe
+ */
+export declare const getUniverse: (universeId: string, options?: SecondParameter<typeof paRequest>) => Promise<Universe>;
+export declare const getGetUniverseQueryKey: (universeId: string) => readonly [`/universes/${string}`];
+export declare const getGetUniverseQueryOptions: <TData = Universe, TError = import("../../model").Error>(universeId: string, options?: {
+    query?: UseQueryOptions<Universe, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<Universe, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetUniverseQueryResult = NonNullable<Awaited<ReturnType<typeof getUniverse>>>;
+export type GetUniverseQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get a universe
+ */
+export declare function useGetUniverse<TData = Awaited<ReturnType<typeof getUniverse>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUniverse>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Registers the universe with Perf Advisor, or replaces the spec of a universe already
+ * registered. YBA and YBM call this when a universe is added to Perf Advisor. Registering a
+ * universe Perf Advisor doesn't know yet takes a session or API token; YBA and YBM tokens are
+ * checked against a registered universe, so they can only update one.
+ * @summary Register or update a universe
+ */
+export declare const registerUniverse: (universeId: string, universeSpec: NonReadonly<UniverseSpec>, options?: SecondParameter<typeof paRequest>) => Promise<Universe>;
+export declare const getRegisterUniverseMutationKey: () => readonly ["registerUniverse"];
+export declare const getRegisterUniverseMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Universe, TError, RegisterUniverseMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<Universe, TError, RegisterUniverseMutationVariables, TContext>;
+export type RegisterUniverseMutationResult = NonNullable<Awaited<ReturnType<typeof registerUniverse>>>;
+export type RegisterUniverseMutationBody = NonReadonly<UniverseSpec>;
+export type RegisterUniverseMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | ConflictResponse | InternalErrorResponse;
+export type RegisterUniverseMutationVariables = {
+    universeId: string;
+    data: NonReadonly<UniverseSpec>;
+};
+/**
+* @summary Register or update a universe
+*/
+export declare const useRegisterUniverse: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Universe, TError, RegisterUniverseMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<Universe, TError, RegisterUniverseMutationVariables, TContext>;
+/**
+* Stops monitoring the universe and removes its registration.
+* @summary Delete a universe
+*/
+export declare const deleteUniverse: (universeId: string, params?: DeleteUniverseParams, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteUniverseMutationKey: () => readonly ["deleteUniverse"];
+export declare const getDeleteUniverseMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUniverseMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteUniverseMutationVariables, TContext>;
+export type DeleteUniverseMutationResult = NonNullable<Awaited<ReturnType<typeof deleteUniverse>>>;
+export type DeleteUniverseMutationError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteUniverseMutationVariables = {
+    universeId: string;
+    params?: DeleteUniverseParams;
+};
+/**
+* @summary Delete a universe
+*/
+export declare const useDeleteUniverse: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUniverseMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteUniverseMutationVariables, TContext>;
+/**
+* Lists the nodes the universe had at any point in the time range, which defaults to the last
+* day, including nodes removed during it. Ordered by name, ascending by default.
+* @summary List a universe's nodes
+*/
+export declare const listUniverseNodes: (universeId: string, params?: ListUniverseNodesParams, options?: SecondParameter<typeof paRequest>) => Promise<UniverseNodePagedResp>;
+export declare const getListUniverseNodesQueryKey: (universeId: string, params?: ListUniverseNodesParams) => readonly [`/universes/${string}/nodes`, ...ListUniverseNodesParams[]];
+export declare const getListUniverseNodesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").UniverseNode[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListUniverseNodesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").UniverseNode[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").UniverseNode[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListUniverseNodesQueryResult = NonNullable<Awaited<ReturnType<typeof listUniverseNodes>>>;
+export type ListUniverseNodesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List a universe's nodes
+ */
+export declare function useListUniverseNodes<TData = Awaited<ReturnType<typeof listUniverseNodes>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListUniverseNodesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listUniverseNodes>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Starts syncing the given metadata from the universe right away rather than on the next
+ * scheduled sync. Returns once the syncs are started; their progress is in the universe's
+ * `info.sync.processes`.
+ * @summary Refresh universe metadata
+ */
+export declare const refreshUniverseMetadata: (universeId: string, metadataRefreshSpec: MetadataRefreshSpec, options?: SecondParameter<typeof paRequest>) => Promise<MetadataRefresh>;
+export declare const getRefreshUniverseMetadataMutationKey: () => readonly ["refreshUniverseMetadata"];
+export declare const getRefreshUniverseMetadataMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<MetadataRefresh, TError, RefreshUniverseMetadataMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<MetadataRefresh, TError, RefreshUniverseMetadataMutationVariables, TContext>;
+export type RefreshUniverseMetadataMutationResult = NonNullable<Awaited<ReturnType<typeof refreshUniverseMetadata>>>;
+export type RefreshUniverseMetadataMutationBody = MetadataRefreshSpec;
+export type RefreshUniverseMetadataMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type RefreshUniverseMetadataMutationVariables = {
+    universeId: string;
+    data: MetadataRefreshSpec;
+};
+/**
+* @summary Refresh universe metadata
+*/
+export declare const useRefreshUniverseMetadata: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<MetadataRefresh, TError, RefreshUniverseMetadataMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<MetadataRefresh, TError, RefreshUniverseMetadataMutationVariables, TContext>;
+/**
+* Lists the runtime configuration effective for the universe: values set for the universe,
+* otherwise inherited from its customer, globally, or the defaults. Ordered by key.
+* @summary List a universe's runtime configuration
+*/
+export declare const listUniverseRuntimeConfigs: (universeId: string, params?: ListUniverseRuntimeConfigsParams, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig[]>;
+export declare const getListUniverseRuntimeConfigsQueryKey: (universeId: string, params?: ListUniverseRuntimeConfigsParams) => readonly [`/universes/${string}/runtime-configs`, ...ListUniverseRuntimeConfigsParams[]];
+export declare const getListUniverseRuntimeConfigsQueryOptions: <TData = RuntimeConfig[], TError = import("../../model").Error>(universeId: string, params?: ListUniverseRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListUniverseRuntimeConfigsQueryResult = NonNullable<Awaited<ReturnType<typeof listUniverseRuntimeConfigs>>>;
+export type ListUniverseRuntimeConfigsQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List a universe's runtime configuration
+ */
+export declare function useListUniverseRuntimeConfigs<TData = Awaited<ReturnType<typeof listUniverseRuntimeConfigs>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListUniverseRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listUniverseRuntimeConfigs>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Sets the value of the key for this universe only.
+ * @summary Set a runtime configuration value for a universe
+ */
+export declare const setUniverseRuntimeConfig: (universeId: string, key: string, runtimeConfigSpec: RuntimeConfigSpec, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig>;
+export declare const getSetUniverseRuntimeConfigMutationKey: () => readonly ["setUniverseRuntimeConfig"];
+export declare const getSetUniverseRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetUniverseRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<RuntimeConfig, TError, SetUniverseRuntimeConfigMutationVariables, TContext>;
+export type SetUniverseRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof setUniverseRuntimeConfig>>>;
+export type SetUniverseRuntimeConfigMutationBody = RuntimeConfigSpec;
+export type SetUniverseRuntimeConfigMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type SetUniverseRuntimeConfigMutationVariables = {
+    universeId: string;
+    key: string;
+    data: RuntimeConfigSpec;
+};
+/**
+* @summary Set a runtime configuration value for a universe
+*/
+export declare const useSetUniverseRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetUniverseRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<RuntimeConfig, TError, SetUniverseRuntimeConfigMutationVariables, TContext>;
+/**
+* Removes the value set for this universe, so the inherited value applies again.
+* @summary Remove a universe's runtime configuration value
+*/
+export declare const deleteUniverseRuntimeConfig: (universeId: string, key: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteUniverseRuntimeConfigMutationKey: () => readonly ["deleteUniverseRuntimeConfig"];
+export declare const getDeleteUniverseRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUniverseRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteUniverseRuntimeConfigMutationVariables, TContext>;
+export type DeleteUniverseRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof deleteUniverseRuntimeConfig>>>;
+export type DeleteUniverseRuntimeConfigMutationError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteUniverseRuntimeConfigMutationVariables = {
+    universeId: string;
+    key: string;
+};
+/**
+* @summary Remove a universe's runtime configuration value
+*/
+export declare const useDeleteUniverseRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUniverseRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteUniverseRuntimeConfigMutationVariables, TContext>;
+export {};

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

@@ -0,0 +1,134 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListUsersParams } from '../../model/listUsersParams';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import type { User } from '../../model/user';
+import type { UserPagedResp } from '../../model/userPagedResp';
+import type { UserSpec } from '../../model/userSpec';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the local Perf Advisor users. Ordered by name, ascending by default.
+ * @summary List users
+ */
+export declare const listUsers: (params?: ListUsersParams, options?: SecondParameter<typeof paRequest>) => Promise<UserPagedResp>;
+export declare const getListUsersQueryKey: (params?: ListUsersParams) => readonly ["/users", ...ListUsersParams[]];
+export declare const getListUsersQueryOptions: <TData = import("../../model").Pagination & {
+    entities: User[];
+}, TError = import("../../model").Error>(params?: ListUsersParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: User[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: User[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListUsersQueryResult = NonNullable<Awaited<ReturnType<typeof listUsers>>>;
+export type ListUsersQueryError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List users
+ */
+export declare function useListUsers<TData = Awaited<ReturnType<typeof listUsers>>, TError = BadRequestResponse | UnauthorizedResponse | InternalErrorResponse>(params?: ListUsersParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listUsers>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Creates a local Perf Advisor user. Perf Advisor assigns the UUID.
+ * @summary Create a user
+ */
+export declare const createUser: (userSpec: UserSpec, options?: SecondParameter<typeof paRequest>) => Promise<User>;
+export declare const getCreateUserMutationKey: () => readonly ["createUser"];
+export declare const getCreateUserMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<User, TError, CreateUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<User, TError, CreateUserMutationVariables, TContext>;
+export type CreateUserMutationResult = NonNullable<Awaited<ReturnType<typeof createUser>>>;
+export type CreateUserMutationBody = UserSpec;
+export type CreateUserMutationError = BadRequestResponse | UnauthorizedResponse | ConflictResponse | InternalErrorResponse;
+export type CreateUserMutationVariables = {
+    data: UserSpec;
+};
+/**
+* @summary Create a user
+*/
+export declare const useCreateUser: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<User, TError, CreateUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<User, TError, CreateUserMutationVariables, TContext>;
+/**
+* Returns a local Perf Advisor user.
+* @summary Get a user
+*/
+export declare const getUser: (userId: string, options?: SecondParameter<typeof paRequest>) => Promise<User>;
+export declare const getGetUserQueryKey: (userId: string) => readonly [`/users/${string}`];
+export declare const getGetUserQueryOptions: <TData = User, TError = import("../../model").Error>(userId: string, options?: {
+    query?: UseQueryOptions<User, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<User, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetUserQueryResult = NonNullable<Awaited<ReturnType<typeof getUser>>>;
+export type GetUserQueryError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get a user
+ */
+export declare function useGetUser<TData = Awaited<ReturnType<typeof getUser>>, TError = UnauthorizedResponse | NotFoundResponse | InternalErrorResponse>(userId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getUser>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Replaces the spec of a user.
+ * @summary Edit a user
+ */
+export declare const editUser: (userId: string, userSpec: UserSpec, options?: SecondParameter<typeof paRequest>) => Promise<User>;
+export declare const getEditUserMutationKey: () => readonly ["editUser"];
+export declare const getEditUserMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<User, TError, EditUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<User, TError, EditUserMutationVariables, TContext>;
+export type EditUserMutationResult = NonNullable<Awaited<ReturnType<typeof editUser>>>;
+export type EditUserMutationBody = UserSpec;
+export type EditUserMutationError = BadRequestResponse | UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type EditUserMutationVariables = {
+    userId: string;
+    data: UserSpec;
+};
+/**
+* @summary Edit a user
+*/
+export declare const useEditUser: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<User, TError, EditUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<User, TError, EditUserMutationVariables, TContext>;
+/**
+* Deletes a local Perf Advisor user.
+* @summary Delete a user
+*/
+export declare const deleteUser: (userId: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteUserMutationKey: () => readonly ["deleteUser"];
+export declare const getDeleteUserMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteUserMutationVariables, TContext>;
+export type DeleteUserMutationResult = NonNullable<Awaited<ReturnType<typeof deleteUser>>>;
+export type DeleteUserMutationError = UnauthorizedResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteUserMutationVariables = {
+    userId: string;
+};
+/**
+* @summary Delete a user
+*/
+export declare const useDeleteUser: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteUserMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteUserMutationVariables, TContext>;
+export {};

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

@@ -0,0 +1,178 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { DatabaseStatsPagedResp } from '../../model/databaseStatsPagedResp';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { GetQueryStatsParams } from '../../model/getQueryStatsParams';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListDatabaseStatsParams } from '../../model/listDatabaseStatsParams';
+import type { ListNodeStatsParams } from '../../model/listNodeStatsParams';
+import type { ListQueriesParams } from '../../model/listQueriesParams';
+import type { ListQueryStatsParams } from '../../model/listQueryStatsParams';
+import type { NodeStatsPagedResp } from '../../model/nodeStatsPagedResp';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { QueryPagedResp } from '../../model/queryPagedResp';
+import type { QueryStats } from '../../model/queryStats';
+import type { QueryStatsPagedResp } from '../../model/queryStatsPagedResp';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the YSQL statements (from pg_stat_statements) and the YCQL statements active in the
+ * time range, which defaults to the last day: their text and identity, without statistics.
+ * `listQueryStats` has the statistics. YSQL and YCQL statements are read separately and
+ * merged in memory. Ordered by `sort_by`, ascending by default. Statements without the sorted
+ * value (a YCQL statement has no user) come last in either direction.
+ * @summary List statements
+ */
+export declare const listQueries: (universeId: string, params?: ListQueriesParams, options?: SecondParameter<typeof paRequest>) => Promise<QueryPagedResp>;
+export declare const getListQueriesQueryKey: (universeId: string, params?: ListQueriesParams) => readonly [`/universes/${string}/queries`, ...ListQueriesParams[]];
+export declare const getListQueriesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").Query[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListQueriesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").Query[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").Query[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListQueriesQueryResult = NonNullable<Awaited<ReturnType<typeof listQueries>>>;
+export type ListQueriesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List statements
+ */
+export declare function useListQueries<TData = Awaited<ReturnType<typeof listQueries>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListQueriesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listQueries>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists the statistics of YSQL, YCQL and background statements over the time range, which
+ * defaults to the last day. Only statements with activity in the time range are listed; for
+ * one statement whatever its activity, use `getQueryStats`. Ordered by `sort_by`, descending
+ * by default.
+ * @summary List statement statistics
+ */
+export declare const listQueryStats: (universeId: string, params?: ListQueryStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<QueryStatsPagedResp>;
+export declare const getListQueryStatsQueryKey: (universeId: string, params?: ListQueryStatsParams) => readonly [`/universes/${string}/query-stats`, ...ListQueryStatsParams[]];
+export declare const getListQueryStatsQueryOptions: <TData = import("../../model").Pagination & {
+    entities: QueryStats[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListQueryStatsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: QueryStats[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: QueryStats[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListQueryStatsQueryResult = NonNullable<Awaited<ReturnType<typeof listQueryStats>>>;
+export type ListQueryStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List statement statistics
+ */
+export declare function useListQueryStats<TData = Awaited<ReturnType<typeof listQueryStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListQueryStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listQueryStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns one statement and its statistics over the time range, which defaults to the last
+ * day. Unlike `listQueryStats`, it returns the statement even without activity in the time
+ * range. For a YSQL statement, `info.plans` holds the execution plans, recorded by Query Plan
+ * Management, that were used in the time range. Unlike v1, which returned every retained plan
+ * when called without a start time, older plans need an earlier `start_time`. A background
+ * activity's id (0 to 13) is only found with `db_id` 0.
+ * @summary Get statement statistics
+ */
+export declare const getQueryStats: (universeId: string, queryKeyParam: string, params?: GetQueryStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<QueryStats>;
+export declare const getGetQueryStatsQueryKey: (universeId: string, queryKeyParam: string, params?: GetQueryStatsParams) => readonly [`/universes/${string}/query-stats/${string}`, ...GetQueryStatsParams[]];
+export declare const getGetQueryStatsQueryOptions: <TData = QueryStats, TError = import("../../model").Error>(universeId: string, queryKeyParam: string, params?: GetQueryStatsParams, options?: {
+    query?: UseQueryOptions<QueryStats, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<QueryStats, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetQueryStatsQueryResult = NonNullable<Awaited<ReturnType<typeof getQueryStats>>>;
+export type GetQueryStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get statement statistics
+ */
+export declare function useGetQueryStats<TData = Awaited<ReturnType<typeof getQueryStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, queryKeyParam: string, params?: GetQueryStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getQueryStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists the statistics of YSQL databases and YCQL keyspaces over the time range, which
+ * defaults to the last day. A keyspace has `cpu.universe_ratio`, from active session history,
+ * but not the other `cpu` figures or `storage`, which are YSQL metrics. `load.total_eps_ratio`
+ * is not set, and `summary` only sets `total_size_bytes`. Ordered by `sort_by`, descending by
+ * default.
+ * @summary List database statistics
+ */
+export declare const listDatabaseStats: (universeId: string, params?: ListDatabaseStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<DatabaseStatsPagedResp>;
+export declare const getListDatabaseStatsQueryKey: (universeId: string, params?: ListDatabaseStatsParams) => readonly [`/universes/${string}/database-stats`, ...ListDatabaseStatsParams[]];
+export declare const getListDatabaseStatsQueryOptions: <TData = import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").DatabaseStats[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListDatabaseStatsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        summary?: import("../../model").StatsSummary | undefined;
+        entities: import("../../model").DatabaseStats[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").DatabaseStats[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListDatabaseStatsQueryResult = NonNullable<Awaited<ReturnType<typeof listDatabaseStats>>>;
+export type ListDatabaseStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List database statistics
+ */
+export declare function useListDatabaseStats<TData = Awaited<ReturnType<typeof listDatabaseStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListDatabaseStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listDatabaseStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists statistics of the universe's nodes over the time range, which defaults to the last
+ * day. Ordered by `sort_by`, descending by default.
+ * @summary List node statistics
+ */
+export declare const listNodeStats: (universeId: string, params?: ListNodeStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<NodeStatsPagedResp>;
+export declare const getListNodeStatsQueryKey: (universeId: string, params?: ListNodeStatsParams) => readonly [`/universes/${string}/node-stats`, ...ListNodeStatsParams[]];
+export declare const getListNodeStatsQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").NodeStats[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListNodeStatsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").NodeStats[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").NodeStats[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListNodeStatsQueryResult = NonNullable<Awaited<ReturnType<typeof listNodeStats>>>;
+export type ListNodeStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List node statistics
+ */
+export declare function useListNodeStats<TData = Awaited<ReturnType<typeof listNodeStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListNodeStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listNodeStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/generated/api.d.ts

@@ -0,0 +1,11 @@
+export * from './api/anomaly/anomaly';
+export * from './api/customer/customer';
+export * from './api/export-config/export-config';
+export * from './api/graph/graph';
+export * from './api/info/info';
+export * from './api/runtime-config/runtime-config';
+export * from './api/schema/schema';
+export * from './api/support-bundle/support-bundle';
+export * from './api/universe/universe';
+export * from './api/user/user';
+export * from './api/workload/workload';

package/dist/generated/model/activityExclusions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Perf Advisor API
+ * Perf Advisor v2 REST API.
+ *
+ * Resources are returned as `{ spec, info }`: `spec` holds the properties a client sets,
+ * `info` holds read-only properties Perf Advisor computes.
+ *
+ * OpenAPI spec version: v2
+ */
+/**
+ * Activity to leave out of the active session history the rows are ranked by.
+ */
+export interface ActivityExclusions {
+    /** Leave out activity in these wait event types. */
+    exclude_wait_event_types?: string[];
+    /** Leave out activity in these wait events. */
+    exclude_wait_events?: string[];
+    /**
+       * Leave out the activity of these statements, by the `query_id` statement statistics report: a YSQL or YCQL query id, or a background activity's id (0 to 13).
+       * @items.pattern ^-?\d+$
+       */
+    exclude_query_ids?: string[];
+}

package/dist/generated/model/activityPeriod.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Perf Advisor API
+ * Perf Advisor v2 REST API.
+ *
+ * Resources are returned as `{ spec, info }`: `spec` holds the properties a client sets,
+ * `info` holds read-only properties Perf Advisor computes.
+ *
+ * OpenAPI spec version: v2
+ */
+/**
+ * When a statement was first and last seen active.
+ */
+export interface ActivityPeriod {
+    /** When the statement was first seen active. */
+    readonly first_active?: string;
+    /** When the statement was last seen active. */
+    readonly last_active?: string;
+}