@prefecthq/prefect-ui-library 1.0.0

package/dist/types/src/router/routes.d.ts

@@ -0,0 +1,277 @@
+import { InjectionKey } from 'vue';
+import { RouteComponent, RouteLocationRaw, RouteRecordRaw } from 'vue-router';
+export type Route = Exclude<RouteLocationRaw, string>;
+type CreateWorkspaceRoutesConfig = {
+    accountId: string;
+    workspaceId: string;
+};
+export declare function createWorkspaceRoutes(config?: CreateWorkspaceRoutesConfig): {
+    flowRuns: () => {
+        readonly name: "workspace.flow-runs";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    flowRun: (flowRunId: string) => {
+        readonly name: "workspace.flow-runs.flow-run";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowRunId: string;
+        };
+    };
+    flowRunRadar: (flowRunId: string) => {
+        readonly name: "workspace.flow-runs.flow-run-radar";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowRunId: string;
+        };
+    };
+    taskRun: (taskRunId: string) => {
+        readonly name: "workspace.flow-runs.task-run";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly taskRunId: string;
+        };
+    };
+    flows: () => {
+        readonly name: "workspace.flows";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    flow: (flowId: string) => {
+        readonly name: "workspace.flows.flow";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowId: string;
+        };
+    };
+    deployments: () => {
+        readonly name: "workspace.deployments";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    deployment: (deploymentId: string) => {
+        readonly name: "workspace.deployments.deployment";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+    };
+    deploymentEdit: (deploymentId: string) => {
+        readonly name: "workspace.deployments.deployment-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+    };
+    deploymentFlowRunCreate: (deploymentId: string, parameters?: Record<string, unknown>) => {
+        readonly name: "workspace.deployments.deployment-flow-run-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+        readonly query: {
+            parameters: string;
+        } | {
+            parameters?: undefined;
+        };
+    };
+    workQueues: () => {
+        readonly name: "workspace.work-queues";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workQueue: (workQueueId: string) => {
+        readonly name: "workspace.work-queues.work-queue";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workQueueId: string;
+        };
+    };
+    workQueueCreate: () => {
+        readonly name: "workspace.work-queues.work-queue-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workQueueEdit: (workQueueId: string) => {
+        readonly name: "workspace.work-queues.work-queue-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workQueueId: string;
+        };
+    };
+    blocks: () => {
+        readonly name: "workspace.blocks";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    blocksCatalog: () => {
+        readonly name: "workspace.blocks.catalog";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    blocksCatalogView: (blockTypeSlug: string) => {
+        readonly name: "workspace.blocks.catalog-view";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockTypeSlug: string;
+        };
+    };
+    blockCreate: (blockTypeSlug: string) => {
+        readonly name: "workspace.blocks.block-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockTypeSlug: string;
+        };
+    };
+    block: (blockDocumentId: string) => {
+        readonly name: "workspace.blocks.block";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockDocumentId: string;
+        };
+    };
+    blockEdit: (blockDocumentId: string) => {
+        readonly name: "workspace.blocks.block-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockDocumentId: string;
+        };
+    };
+    notifications: () => {
+        readonly name: "workspace.notifications";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    notificationCreate: () => {
+        readonly name: "workspace.notifications.create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    notificationEdit: (notificationId: string) => {
+        readonly name: "workspace.notifications.notification-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly notificationId: string;
+        };
+    };
+    concurrencyLimit: (concurrencyLimitId: string) => {
+        readonly name: "workspace.concurrency-limits.concurrency-limit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly concurrencyLimitId: string;
+        };
+    };
+    concurrencyLimits: () => {
+        readonly name: "workspace.concurrency-limits";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPools: () => {
+        readonly name: "workspace.work-pools";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPool: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolCreate: () => {
+        readonly name: "workspace.work-pools.work-pool-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPoolEdit: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolQueue: (workPoolName: string, workPoolQueueName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+            readonly workPoolQueueName: string;
+        };
+    };
+    workPoolQueueCreate: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolQueueEdit: (workPoolName: string, workPoolQueueName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+            readonly workPoolQueueName: string;
+        };
+    };
+};
+type WorkspaceRoutes = ReturnType<typeof createWorkspaceRoutes>;
+type WorkspaceRouteKey = keyof WorkspaceRoutes;
+type WorkspaceRoute = ReturnType<WorkspaceRoutes[WorkspaceRouteKey]>;
+type WorkspaceNamedRoute = WorkspaceRoute['name'];
+type WorkspaceRouteRecordParent = {
+    name?: WorkspaceNamedRoute;
+    children: WorkspaceRouteRecord[];
+};
+type WorkspaceRouteRecordChild = {
+    name: WorkspaceNamedRoute;
+};
+type WorkspaceRouteRecord = Omit<RouteRecordRaw, 'name' | 'children'> & WorkspaceRouteRecordParent | WorkspaceRouteRecordChild;
+export declare const workspaceRoutesKey: InjectionKey<WorkspaceRoutes>;
+type WorkspaceComponent = () => Promise<RouteComponent>;
+type WorkspaceRouteComponents = Record<WorkspaceRouteKey, WorkspaceComponent>;
+export declare function createWorkspaceRouteRecords(components: Partial<WorkspaceRouteComponents>): WorkspaceRouteRecord[];
+export {};

package/dist/types/src/services/AdminApi.d.ts

@@ -0,0 +1,7 @@
+import { ServerSettings } from '../models/ServerSettings';
+import { Api, ApiRoute } from '../services/Api';
+export declare class AdminApi extends Api {
+    protected route: ApiRoute;
+    getSettings(): Promise<ServerSettings>;
+    getVersion(): Promise<string>;
+}

package/dist/types/src/services/Api.d.ts

@@ -0,0 +1,35 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { ApiRouteParams } from '../models/ApiRouteParams';
+import { Require } from '../types/utilities';
+/**
+ * @deprecated
+ */
+export type ApiRoute = string | ((params?: ApiRouteParams) => string);
+/**
+ * @deprecated
+ */
+export type ApiServer = string | Promise<string>;
+/**
+ * @deprecated
+ */
+export declare abstract class Api {
+    protected server: ApiServer;
+    protected route: ApiRoute;
+    private _config;
+    private _instance;
+    private _params;
+    constructor(config?: AxiosRequestConfig);
+    protected instance(): Promise<AxiosInstance>;
+    protected config(): Promise<AxiosRequestConfig>;
+    protected request<T = any, R = AxiosResponse<T>>(config: Require<AxiosRequestConfig, 'url' | 'method'>): Promise<R>;
+    protected get<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected delete<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected head<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected options<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected post<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    protected put<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    protected patch<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    protected withParams(params?: ApiRouteParams): this;
+    protected getRoute(params?: ApiRouteParams): string;
+    private withRoute;
+}

package/dist/types/src/services/BatchProcessor/BatchProcessor.d.ts

@@ -0,0 +1,28 @@
+import { MaybePromise } from '../../types';
+export type BatchCallbackLookup<V, R> = (value: V) => MaybePromise<R>;
+export type BatchCallback<V, R> = (values: V[]) => MaybePromise<Map<V, R>> | BatchCallbackLookup<V, R>;
+export type BatchOptions = {
+    maxBatchSize?: number;
+    maxWaitMilliseconds?: number;
+};
+export declare class BatchProcessor<V, R> {
+    private readonly callback;
+    private readonly options;
+    private readonly queue;
+    private timeout;
+    private waitingSince;
+    constructor(callback: BatchCallback<V, R>, options?: BatchOptions);
+    batch(value: V): Promise<R>;
+    process(): void;
+    private requestProcessQueue;
+    private waitToProcessQueue;
+    private shouldProcessNow;
+    private maxBatchSizeReached;
+    private maxWaitReached;
+    private getBatchToProcess;
+    private processQueue;
+    private resolveBatchUsingMap;
+    private resolveBatchUsingLookup;
+    private rejectBatch;
+    private isBatchCallbackLookup;
+}

package/dist/types/src/services/BatchProcessor/index.d.ts

@@ -0,0 +1 @@
+export * from './BatchProcessor';

package/dist/types/src/services/HealthApi.d.ts

@@ -0,0 +1,5 @@
+import { Api, ApiRoute } from '../services/Api';
+export declare class HealthApi extends Api {
+    protected route: ApiRoute;
+    getHealth(): Promise<string>;
+}