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

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

@@ -0,0 +1,62 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { Graph } from '../../model/graph';
+import type { GraphCatalogEntry } from '../../model/graphCatalogEntry';
+import type { GraphQuerySpec } from '../../model/graphQuerySpec';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+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 graphs Perf Advisor can draw, with the labels each can be filtered and split by.
+ * Ordered as the UI shows them.
+ * @summary List graphs
+ */
+export declare const listGraphs: (options?: SecondParameter<typeof paRequest>) => Promise<GraphCatalogEntry[]>;
+export declare const getListGraphsQueryKey: () => readonly ["/graphs"];
+export declare const getListGraphsQueryOptions: <TData = GraphCatalogEntry[], TError = import("../../model").Error>(options?: {
+    query?: UseQueryOptions<GraphCatalogEntry[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<GraphCatalogEntry[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListGraphsQueryResult = NonNullable<Awaited<ReturnType<typeof listGraphs>>>;
+export type ListGraphsQueryError = UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List graphs
+ */
+export declare function useListGraphs<TData = Awaited<ReturnType<typeof listGraphs>>, TError = UnauthorizedResponse | InternalErrorResponse>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listGraphs>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns the data of the given graphs for the universe, in the order they were requested. A
+ * graph that could not be drawn has `successful: false` and an `error_message`; the others
+ * are still returned.
+ * @summary Query graphs of a universe
+ */
+export declare const queryUniverseGraphs: (universeId: string, graphQuerySpec: GraphQuerySpec[], options?: SecondParameter<typeof paRequest>) => Promise<Graph[]>;
+export declare const getQueryUniverseGraphsMutationKey: () => readonly ["queryUniverseGraphs"];
+export declare const getQueryUniverseGraphsMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Graph[], TError, QueryUniverseGraphsMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<Graph[], TError, QueryUniverseGraphsMutationVariables, TContext>;
+export type QueryUniverseGraphsMutationResult = NonNullable<Awaited<ReturnType<typeof queryUniverseGraphs>>>;
+export type QueryUniverseGraphsMutationBody = GraphQuerySpec[];
+export type QueryUniverseGraphsMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+export type QueryUniverseGraphsMutationVariables = {
+    universeId: string;
+    data: GraphQuerySpec[];
+};
+/**
+* @summary Query graphs of a universe
+*/
+export declare const useQueryUniverseGraphs: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Graph[], TError, QueryUniverseGraphsMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<Graph[], TError, QueryUniverseGraphsMutationVariables, TContext>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { PerfAdvisor } from '../../model/perfAdvisor';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Returns the version of this Perf Advisor instance and how it is deployed.
+ * @summary Get Perf Advisor information
+ */
+export declare const getPaInfo: (options?: SecondParameter<typeof paRequest>) => Promise<PerfAdvisor>;
+export declare const getGetPaInfoQueryKey: () => readonly ["/pa-info"];
+export declare const getGetPaInfoQueryOptions: <TData = PerfAdvisor, TError = import("../../model").Error>(options?: {
+    query?: UseQueryOptions<PerfAdvisor, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<PerfAdvisor, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetPaInfoQueryResult = NonNullable<Awaited<ReturnType<typeof getPaInfo>>>;
+export type GetPaInfoQueryError = UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary Get Perf Advisor information
+ */
+export declare function useGetPaInfo<TData = Awaited<ReturnType<typeof getPaInfo>>, TError = UnauthorizedResponse | InternalErrorResponse>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getPaInfo>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

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

@@ -0,0 +1,80 @@
+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 { ListRuntimeConfigsParams } from '../../model/listRuntimeConfigsParams';
+import type { RuntimeConfig } from '../../model/runtimeConfig';
+import type { RuntimeConfigSpec } from '../../model/runtimeConfigSpec';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the runtime configuration effective globally. Ordered by key.
+ * @summary List globally runtime configuration
+ */
+export declare const listRuntimeConfigs: (params?: ListRuntimeConfigsParams, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig[]>;
+export declare const getListRuntimeConfigsQueryKey: (params?: ListRuntimeConfigsParams) => readonly ["/runtime-configs", ...ListRuntimeConfigsParams[]];
+export declare const getListRuntimeConfigsQueryOptions: <TData = RuntimeConfig[], TError = import("../../model").Error>(params?: ListRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<RuntimeConfig[], TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListRuntimeConfigsQueryResult = NonNullable<Awaited<ReturnType<typeof listRuntimeConfigs>>>;
+export type ListRuntimeConfigsQueryError = UnauthorizedResponse | InternalErrorResponse;
+/**
+ * @summary List globally runtime configuration
+ */
+export declare function useListRuntimeConfigs<TData = Awaited<ReturnType<typeof listRuntimeConfigs>>, TError = UnauthorizedResponse | InternalErrorResponse>(params?: ListRuntimeConfigsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listRuntimeConfigs>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Sets the value of the key globally.
+ * @summary Set a runtime configuration value globally
+ */
+export declare const setRuntimeConfig: (key: string, runtimeConfigSpec: RuntimeConfigSpec, options?: SecondParameter<typeof paRequest>) => Promise<RuntimeConfig>;
+export declare const getSetRuntimeConfigMutationKey: () => readonly ["setRuntimeConfig"];
+export declare const getSetRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<RuntimeConfig, TError, SetRuntimeConfigMutationVariables, TContext>;
+export type SetRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof setRuntimeConfig>>>;
+export type SetRuntimeConfigMutationBody = RuntimeConfigSpec;
+export type SetRuntimeConfigMutationError = BadRequestResponse | UnauthorizedResponse | ConflictResponse | InternalErrorResponse;
+export type SetRuntimeConfigMutationVariables = {
+    key: string;
+    data: RuntimeConfigSpec;
+};
+/**
+* @summary Set a runtime configuration value globally
+*/
+export declare const useSetRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<RuntimeConfig, TError, SetRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<RuntimeConfig, TError, SetRuntimeConfigMutationVariables, TContext>;
+/**
+* Removes the value set globally, so the inherited value or the default applies again.
+* @summary Remove a runtime configuration value globally
+*/
+export declare const deleteRuntimeConfig: (key: string, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteRuntimeConfigMutationKey: () => readonly ["deleteRuntimeConfig"];
+export declare const getDeleteRuntimeConfigMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteRuntimeConfigMutationVariables, TContext>;
+export type DeleteRuntimeConfigMutationResult = NonNullable<Awaited<ReturnType<typeof deleteRuntimeConfig>>>;
+export type DeleteRuntimeConfigMutationError = UnauthorizedResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteRuntimeConfigMutationVariables = {
+    key: string;
+};
+/**
+* @summary Remove a runtime configuration value globally
+*/
+export declare const useDeleteRuntimeConfig: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteRuntimeConfigMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteRuntimeConfigMutationVariables, TContext>;
+export {};

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

@@ -0,0 +1,214 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { DatabasePagedResp } from '../../model/databasePagedResp';
+import type { DatabaseSchemaPagedResp } from '../../model/databaseSchemaPagedResp';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { IndexPagedResp } from '../../model/indexPagedResp';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListDatabaseSchemasParams } from '../../model/listDatabaseSchemasParams';
+import type { ListDatabasesParams } from '../../model/listDatabasesParams';
+import type { ListIndexesParams } from '../../model/listIndexesParams';
+import type { ListMaterializedViewsParams } from '../../model/listMaterializedViewsParams';
+import type { ListTableStatsParams } from '../../model/listTableStatsParams';
+import type { ListTabletStatsParams } from '../../model/listTabletStatsParams';
+import type { MaterializedViewPagedResp } from '../../model/materializedViewPagedResp';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { TableStatsPagedResp } from '../../model/tableStatsPagedResp';
+import type { TabletStatsPagedResp } from '../../model/tabletStatsPagedResp';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the universe's active YSQL databases and YCQL keyspaces. YugabyteDB's own databases,
+ * such as `system_platform`, are typed `SYSTEM`, as in database statistics. Ordered by name,
+ * then type, ascending by default.
+ * @summary List databases
+ */
+export declare const listDatabases: (universeId: string, params?: ListDatabasesParams, options?: SecondParameter<typeof paRequest>) => Promise<DatabasePagedResp>;
+export declare const getListDatabasesQueryKey: (universeId: string, params?: ListDatabasesParams) => readonly [`/universes/${string}/databases`, ...ListDatabasesParams[]];
+export declare const getListDatabasesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").Database[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListDatabasesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").Database[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").Database[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListDatabasesQueryResult = NonNullable<Awaited<ReturnType<typeof listDatabases>>>;
+export type ListDatabasesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List databases
+ */
+export declare function useListDatabases<TData = Awaited<ReturnType<typeof listDatabases>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListDatabasesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listDatabases>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists the schemas of a YSQL database that hold tables. Ordered by name, ascending by
+ * default.
+ * @summary List the schemas of a database
+ */
+export declare const listDatabaseSchemas: (universeId: string, databaseName: string, params?: ListDatabaseSchemasParams, options?: SecondParameter<typeof paRequest>) => Promise<DatabaseSchemaPagedResp>;
+export declare const getListDatabaseSchemasQueryKey: (universeId: string, databaseName: string, params?: ListDatabaseSchemasParams) => readonly [`/universes/${string}/databases/${string}/schemas`, ...ListDatabaseSchemasParams[]];
+export declare const getListDatabaseSchemasQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").DatabaseSchema[];
+}, TError = import("../../model").Error>(universeId: string, databaseName: string, params?: ListDatabaseSchemasParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").DatabaseSchema[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").DatabaseSchema[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListDatabaseSchemasQueryResult = NonNullable<Awaited<ReturnType<typeof listDatabaseSchemas>>>;
+export type ListDatabaseSchemasQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List the schemas of a database
+ */
+export declare function useListDatabaseSchemas<TData = Awaited<ReturnType<typeof listDatabaseSchemas>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, databaseName: string, params?: ListDatabaseSchemasParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listDatabaseSchemas>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists YSQL tables and YCQL tables and indexes, with their size. A property only one type
+ * has is not set for the other: `table_id`, `columns`, `definition`,
+ * `definition_updated_time` and `colocated` are YSQL-only, `table_uuid`, `index` and `state`
+ * YCQL-only. YSQL and YCQL tables are read separately and merged in memory. Ordered by
+ * `sort_by`, descending by default. Tables without the sorted value (a YCQL table has no
+ * schema) come last in either direction. With `start_time`, the tables that existed in the
+ * window are listed and sizes cover it; without it, only the tables that still exist, with
+ * sizes over the day before `end_time`.
+ * @summary List tables
+ */
+export declare const listTableStats: (universeId: string, params?: ListTableStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<TableStatsPagedResp>;
+export declare const getListTableStatsQueryKey: (universeId: string, params?: ListTableStatsParams) => readonly [`/universes/${string}/table-stats`, ...ListTableStatsParams[]];
+export declare const getListTableStatsQueryOptions: <TData = import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").TableStats[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListTableStatsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        summary?: import("../../model").StatsSummary | undefined;
+        entities: import("../../model").TableStats[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").TableStats[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListTableStatsQueryResult = NonNullable<Awaited<ReturnType<typeof listTableStats>>>;
+export type ListTableStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List tables
+ */
+export declare function useListTableStats<TData = Awaited<ReturnType<typeof listTableStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListTableStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listTableStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists YSQL indexes. With `start_time`, the indexes that existed in the window; without it,
+ * only the indexes that still exist. Ordered by `sort_by`, ascending by default.
+ * @summary List YSQL indexes
+ */
+export declare const listIndexes: (universeId: string, params?: ListIndexesParams, options?: SecondParameter<typeof paRequest>) => Promise<IndexPagedResp>;
+export declare const getListIndexesQueryKey: (universeId: string, params?: ListIndexesParams) => readonly [`/universes/${string}/indexes`, ...ListIndexesParams[]];
+export declare const getListIndexesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").Index[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListIndexesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").Index[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").Index[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListIndexesQueryResult = NonNullable<Awaited<ReturnType<typeof listIndexes>>>;
+export type ListIndexesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List YSQL indexes
+ */
+export declare function useListIndexes<TData = Awaited<ReturnType<typeof listIndexes>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListIndexesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listIndexes>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists YSQL materialized views. With `start_time`, the views that existed in the window;
+ * without it, only the views that still exist. Ordered by `sort_by`, ascending by default.
+ * @summary List YSQL materialized views
+ */
+export declare const listMaterializedViews: (universeId: string, params?: ListMaterializedViewsParams, options?: SecondParameter<typeof paRequest>) => Promise<MaterializedViewPagedResp>;
+export declare const getListMaterializedViewsQueryKey: (universeId: string, params?: ListMaterializedViewsParams) => readonly [`/universes/${string}/materialized-views`, ...ListMaterializedViewsParams[]];
+export declare const getListMaterializedViewsQueryOptions: <TData = import("../../model").Pagination & {
+    entities: import("../../model").MaterializedView[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListMaterializedViewsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: import("../../model").MaterializedView[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: import("../../model").MaterializedView[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListMaterializedViewsQueryResult = NonNullable<Awaited<ReturnType<typeof listMaterializedViews>>>;
+export type ListMaterializedViewsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List YSQL materialized views
+ */
+export declare function useListMaterializedViews<TData = Awaited<ReturnType<typeof listMaterializedViews>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListMaterializedViewsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listMaterializedViews>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Lists tablets, with their load and size over the time range, which defaults to the day
+ * before `end_time`. Ordered by `sort_by`, descending by default.
+ * @summary List tablets
+ */
+export declare const listTabletStats: (universeId: string, params?: ListTabletStatsParams, options?: SecondParameter<typeof paRequest>) => Promise<TabletStatsPagedResp>;
+export declare const getListTabletStatsQueryKey: (universeId: string, params?: ListTabletStatsParams) => readonly [`/universes/${string}/tablet-stats`, ...ListTabletStatsParams[]];
+export declare const getListTabletStatsQueryOptions: <TData = import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").TabletStats[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListTabletStatsParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        summary?: import("../../model").StatsSummary | undefined;
+        entities: import("../../model").TabletStats[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    summary?: import("../../model").StatsSummary | undefined;
+    entities: import("../../model").TabletStats[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListTabletStatsQueryResult = NonNullable<Awaited<ReturnType<typeof listTabletStats>>>;
+export type ListTabletStatsQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List tablets
+ */
+export declare function useListTabletStats<TData = Awaited<ReturnType<typeof listTabletStats>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListTabletStatsParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listTabletStats>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/generated/api/support-bundle/support-bundle.d.ts

@@ -0,0 +1,167 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from 'react-query';
+import type { BadRequestResponse } from '../../model/badRequestResponse';
+import type { ConflictResponse } from '../../model/conflictResponse';
+import type { DeleteSupportBundleParams } from '../../model/deleteSupportBundleParams';
+import type { EstimateSupportBundleSizeParams } from '../../model/estimateSupportBundleSizeParams';
+import type { ForbiddenResponse } from '../../model/forbiddenResponse';
+import type { InternalErrorResponse } from '../../model/internalErrorResponse';
+import type { ListSupportBundlesParams } from '../../model/listSupportBundlesParams';
+import type { NotFoundResponse } from '../../model/notFoundResponse';
+import type { SupportBundle } from '../../model/supportBundle';
+import type { SupportBundlePagedResp } from '../../model/supportBundlePagedResp';
+import type { SupportBundleSizeEstimate } from '../../model/supportBundleSizeEstimate';
+import type { SupportBundleSpec } from '../../model/supportBundleSpec';
+import type { UnauthorizedResponse } from '../../model/unauthorizedResponse';
+import { paRequest } from '../../../http';
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * Lists the universe's support bundles. Ordered by scheduled time, newest first by default
+ * (`direction` `DESC`).
+ * @summary List a universe's support bundles
+ */
+export declare const listSupportBundles: (universeId: string, params?: ListSupportBundlesParams, options?: SecondParameter<typeof paRequest>) => Promise<SupportBundlePagedResp>;
+export declare const getListSupportBundlesQueryKey: (universeId: string, params?: ListSupportBundlesParams) => readonly [`/universes/${string}/support-bundles`, ...ListSupportBundlesParams[]];
+export declare const getListSupportBundlesQueryOptions: <TData = import("../../model").Pagination & {
+    entities: SupportBundle[];
+}, TError = import("../../model").Error>(universeId: string, params?: ListSupportBundlesParams, options?: {
+    query?: UseQueryOptions<import("../../model").Pagination & {
+        entities: SupportBundle[];
+    }, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<import("../../model").Pagination & {
+    entities: SupportBundle[];
+}, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type ListSupportBundlesQueryResult = NonNullable<Awaited<ReturnType<typeof listSupportBundles>>>;
+export type ListSupportBundlesQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary List a universe's support bundles
+ */
+export declare function useListSupportBundles<TData = Awaited<ReturnType<typeof listSupportBundles>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: ListSupportBundlesParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof listSupportBundles>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Starts collecting a support bundle of the universe's data for the time range.
+ * Returns once collection is scheduled; progress is in `info.state`.
+ * @summary Create a support bundle
+ */
+export declare const createSupportBundle: (universeId: string, supportBundleSpec: SupportBundleSpec, options?: SecondParameter<typeof paRequest>) => Promise<SupportBundle>;
+export declare const getCreateSupportBundleMutationKey: () => readonly ["createSupportBundle"];
+export declare const getCreateSupportBundleMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<SupportBundle, TError, CreateSupportBundleMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<SupportBundle, TError, CreateSupportBundleMutationVariables, TContext>;
+export type CreateSupportBundleMutationResult = NonNullable<Awaited<ReturnType<typeof createSupportBundle>>>;
+export type CreateSupportBundleMutationBody = SupportBundleSpec;
+export type CreateSupportBundleMutationError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type CreateSupportBundleMutationVariables = {
+    universeId: string;
+    data: SupportBundleSpec;
+};
+/**
+* @summary Create a support bundle
+*/
+export declare const useCreateSupportBundle: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<SupportBundle, TError, CreateSupportBundleMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<SupportBundle, TError, CreateSupportBundleMutationVariables, TContext>;
+/**
+* Estimates the size of a support bundle for this time window and metric format, without
+* creating it. Both `start_time` and `end_time` are required, and the start must be before
+* the end.
+* @summary Estimate the size of a support bundle
+*/
+export declare const estimateSupportBundleSize: (universeId: string, params?: EstimateSupportBundleSizeParams, options?: SecondParameter<typeof paRequest>) => Promise<SupportBundleSizeEstimate>;
+export declare const getEstimateSupportBundleSizeQueryKey: (universeId: string, params?: EstimateSupportBundleSizeParams) => readonly [`/universes/${string}/support-bundles/size-estimate`, ...EstimateSupportBundleSizeParams[]];
+export declare const getEstimateSupportBundleSizeQueryOptions: <TData = SupportBundleSizeEstimate, TError = import("../../model").Error>(universeId: string, params?: EstimateSupportBundleSizeParams, options?: {
+    query?: UseQueryOptions<SupportBundleSizeEstimate, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<SupportBundleSizeEstimate, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type EstimateSupportBundleSizeQueryResult = NonNullable<Awaited<ReturnType<typeof estimateSupportBundleSize>>>;
+export type EstimateSupportBundleSizeQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Estimate the size of a support bundle
+ */
+export declare function useEstimateSupportBundleSize<TData = Awaited<ReturnType<typeof estimateSupportBundleSize>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, params?: EstimateSupportBundleSizeParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof estimateSupportBundleSize>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Returns a support bundle.
+ * @summary Get a support bundle
+ */
+export declare const getSupportBundle: (universeId: string, supportBundleId: string, options?: SecondParameter<typeof paRequest>) => Promise<SupportBundle>;
+export declare const getGetSupportBundleQueryKey: (universeId: string, supportBundleId: string) => readonly [`/universes/${string}/support-bundles/${string}`];
+export declare const getGetSupportBundleQueryOptions: <TData = SupportBundle, TError = import("../../model").Error>(universeId: string, supportBundleId: string, options?: {
+    query?: UseQueryOptions<SupportBundle, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<SupportBundle, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type GetSupportBundleQueryResult = NonNullable<Awaited<ReturnType<typeof getSupportBundle>>>;
+export type GetSupportBundleQueryError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Get a support bundle
+ */
+export declare function useGetSupportBundle<TData = Awaited<ReturnType<typeof getSupportBundle>>, TError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, supportBundleId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof getSupportBundle>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Deletes the support bundle and, unless `clean_data` is false, its file.
+ * @summary Delete a support bundle
+ */
+export declare const deleteSupportBundle: (universeId: string, supportBundleId: string, params?: DeleteSupportBundleParams, options?: SecondParameter<typeof paRequest>) => Promise<void>;
+export declare const getDeleteSupportBundleMutationKey: () => readonly ["deleteSupportBundle"];
+export declare const getDeleteSupportBundleMutationOptions: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteSupportBundleMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationOptions<void, TError, DeleteSupportBundleMutationVariables, TContext>;
+export type DeleteSupportBundleMutationResult = NonNullable<Awaited<ReturnType<typeof deleteSupportBundle>>>;
+export type DeleteSupportBundleMutationError = UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | ConflictResponse | InternalErrorResponse;
+export type DeleteSupportBundleMutationVariables = {
+    universeId: string;
+    supportBundleId: string;
+    params?: DeleteSupportBundleParams;
+};
+/**
+* @summary Delete a support bundle
+*/
+export declare const useDeleteSupportBundle: <TError = import("../../model").Error, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<void, TError, DeleteSupportBundleMutationVariables, TContext> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseMutationResult<void, TError, DeleteSupportBundleMutationVariables, TContext>;
+/**
+* Returns the bundle file. The bundle must be `COMPLETED`.
+* @summary Download a support bundle
+*/
+export declare const downloadSupportBundle: (universeId: string, supportBundleId: string, options?: SecondParameter<typeof paRequest>) => Promise<Blob>;
+export declare const getDownloadSupportBundleQueryKey: (universeId: string, supportBundleId: string) => readonly [`/universes/${string}/support-bundles/${string}/download`];
+export declare const getDownloadSupportBundleQueryOptions: <TData = Blob, TError = import("../../model").Error>(universeId: string, supportBundleId: string, options?: {
+    query?: UseQueryOptions<Blob, TError, TData, QueryKey> | undefined;
+    request?: SecondParameter<typeof paRequest>;
+} | undefined) => UseQueryOptions<Blob, TError, TData, QueryKey> & {
+    queryKey: QueryKey;
+};
+export type DownloadSupportBundleQueryResult = NonNullable<Awaited<ReturnType<typeof downloadSupportBundle>>>;
+export type DownloadSupportBundleQueryError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse;
+/**
+ * @summary Download a support bundle
+ */
+export declare function useDownloadSupportBundle<TData = Awaited<ReturnType<typeof downloadSupportBundle>>, TError = BadRequestResponse | UnauthorizedResponse | ForbiddenResponse | NotFoundResponse | InternalErrorResponse>(universeId: string, supportBundleId: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof downloadSupportBundle>>, TError, TData>;
+    request?: SecondParameter<typeof paRequest>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};