@prefecthq/prefect-ui-library 2.4.19 → 2.4.21

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

@@ -1,9 +1,5 @@
 import { Api } from '../services/Api';
-export interface IHealthApi {
-    getHealth: () => Promise<boolean>;
-    isHealthy: () => Promise<boolean>;
-}
-export declare class HealthApi extends Api implements IHealthApi {
+export declare class HealthApi extends Api {
     protected routePrefix: string;
     getHealth(): Promise<boolean>;
     isHealthy(): Promise<boolean>;

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

@@ -105,11 +105,7 @@ export declare const mapper: Mapper<{
         string: MapFunction<Date, string>;
     };
     DateRangeSelectValue: {
-        DateRange: MapFunction<NonNullable<import("@prefecthq/prefect-design").DateRangeSelectValue>, {
-            startDate: Date;
-            endDate: Date;
-            timeSpanInSeconds: number;
-        }>;
+        DateRange: MapFunction<import("@prefecthq/prefect-design").DateRangeSelectValue & {}, import("@prefecthq/prefect-design").DateRangeWithTimeSpan>;
     };
     DeploymentFilter: {
         DeploymentFilterRequest: MapFunction<import("..").DeploymentFilter, import("../models/api/Filters").DeploymentFilterRequest>;

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

@@ -23,7 +23,7 @@ export declare const mocker: Mocker<{
     blockType: MockFunction<import("..").BlockType, [(Partial<import("..").BlockType> | undefined)?]>;
     blockTypeSnippet: MockFunction<string, []>;
     boolean: MockFunction<boolean, []>;
-    char: MockFunction<"h" | "d" | "w" | "m" | "y" | "s" | "a" | "b" | "c" | "e" | "f" | "g" | "i" | "j" | "k" | "l" | "n" | "o" | "p" | "q" | "r" | "t" | "u" | "v" | "x" | "z", []>;
+    char: MockFunction<"h" | "d" | "w" | "m" | "y" | "a" | "b" | "c" | "e" | "f" | "g" | "i" | "j" | "k" | "l" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "x" | "z", []>;
     collectionItem: MockFunction<import("..").CollectionItem, [(Partial<import("..").CollectionItem> | undefined)?]>;
     concurrencyLimit: MockFunction<import("..").ConcurrencyLimit, [(Partial<import("..").ConcurrencyLimit> | undefined)?]>;
     concurrencyV2Limit: MockFunction<import("..").ConcurrencyV2Limit, [(Partial<import("..").ConcurrencyV2Limit> | undefined)?]>;

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

@@ -2,16 +2,7 @@ import { Artifact } from '../models';
 import { ArtifactCollection } from '../models/ArtifactCollection';
 import { ArtifactsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceArtifactsApi {
-    getArtifact: (id: string) => Promise<Artifact>;
-    getArtifacts: (filter: ArtifactsFilter) => Promise<Artifact[]>;
-    getArtifactCollection: (key: string) => Promise<ArtifactCollection>;
-    getArtifactCollections: (filter: ArtifactsFilter) => Promise<ArtifactCollection[]>;
-    getArtifactsCount: (filter: ArtifactsFilter) => Promise<number>;
-    getArtifactCollectionsCount: (filter: ArtifactsFilter) => Promise<number>;
-    deleteArtifact: (id: string) => Promise<void>;
-}
-export declare class WorkspaceArtifactsApi extends WorkspaceApi implements IWorkspaceArtifactsApi {
+export declare class WorkspaceArtifactsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     private readonly keyBatcher;

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

@@ -1,8 +1,5 @@
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceBlockCapabilitiesApi {
-    getBlockCapabilities: () => Promise<string[]>;
-}
-export declare class WorkspaceBlockCapabilitiesApi extends WorkspaceApi implements IWorkspaceBlockCapabilitiesApi {
+export declare class WorkspaceBlockCapabilitiesApi extends WorkspaceApi {
     protected routePrefix: string;
     getBlockCapabilities(): Promise<string[]>;
 }

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

@@ -3,15 +3,7 @@ import { BlockDocumentCreate } from '../models/BlockDocumentCreate';
 import { BlockDocumentUpdate } from '../models/BlockDocumentUpdate';
 import { BlockDocumentsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceBlockDocumentsApi {
-    getBlockDocument: (blockDocumentId: string) => Promise<BlockDocument>;
-    getBlockDocuments: (filter: BlockDocumentsFilter) => Promise<BlockDocument[]>;
-    createBlockDocument: (blockDocument: BlockDocumentCreate) => Promise<BlockDocument>;
-    updateBlockDocument: (blockDocumentId: string, blockDocument: BlockDocumentUpdate) => Promise<void>;
-    deleteBlockDocument: (blockDocumentId: string) => Promise<void>;
-    getBlockDocumentsCount: (filter: BlockDocumentsFilter) => Promise<number>;
-}
-export declare class WorkspaceBlockDocumentsApi extends WorkspaceApi implements IWorkspaceBlockDocumentsApi {
+export declare class WorkspaceBlockDocumentsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     getBlockDocument(blockDocumentId: string): Promise<BlockDocument>;

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

@@ -1,12 +1,7 @@
 import { BlockSchema } from '../models/BlockSchema';
 import { BlockSchemasFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceBlockSchemasApi {
-    getBlockSchema: (blockSchemaId: string) => Promise<BlockSchema>;
-    getBlockSchemas: (filter: BlockSchemasFilter) => Promise<BlockSchema[]>;
-    getBlockSchemaForBlockType: (blockTypeId: string) => Promise<BlockSchema>;
-}
-export declare class WorkspaceBlockSchemasApi extends WorkspaceApi implements IWorkspaceBlockSchemasApi {
+export declare class WorkspaceBlockSchemasApi extends WorkspaceApi {
     protected routePrefix: string;
     getBlockSchema(blockSchemaId: string): Promise<BlockSchema>;
     getBlockSchemas(filter?: BlockSchemasFilter): Promise<BlockSchema[]>;

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

@@ -2,13 +2,7 @@ import { BlockDocument } from '../models/BlockDocument';
 import { BlockType } from '../models/BlockType';
 import { BlockTypesFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceBlockTypesApi {
-    getBlockType: (blockTypeId: string) => Promise<BlockType>;
-    getBlockTypeBySlug: (blockTypeSlug: string) => Promise<BlockType>;
-    getBlockTypes: (filter: BlockTypesFilter) => Promise<BlockType[]>;
-    getBlockDocumentsByBlockTypeSlug: (blockTypeSlug: string) => Promise<BlockDocument[]>;
-}
-export declare class WorkspaceBlockTypesApi extends WorkspaceApi implements IWorkspaceBlockTypesApi {
+export declare class WorkspaceBlockTypesApi extends WorkspaceApi {
     protected routePrefix: string;
     getBlockType(blockTypeId: string): Promise<BlockType>;
     getBlockTypeBySlug(blockTypeSlug: string): Promise<BlockType>;

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

@@ -2,15 +2,6 @@ import { ConcurrencyLimit } from '../models/ConcurrencyLimit';
 import { ConcurrencyLimitCreate } from '../models/ConcurrencyLimitCreate';
 import { ConcurrencyLimitsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceConcurrencyLimitsApi {
-    getConcurrencyLimit: (concurrencyLimitId: string) => Promise<ConcurrencyLimit>;
-    getConcurrencyLimits: (filter: ConcurrencyLimitsFilter) => Promise<ConcurrencyLimit[]>;
-    createConcurrencyLimit: (concurrencyLimit: ConcurrencyLimitCreate) => Promise<ConcurrencyLimit>;
-    getConcurrencyLimitByTag: (tag: string) => Promise<ConcurrencyLimit>;
-    deleteConcurrencyLimit: (concurrencyLimitId: string) => Promise<void>;
-    deleteConcurrencyLimitByTag: (tag: string) => Promise<void>;
-    resetConcurrencyLimitByTag: (tag: string) => Promise<ConcurrencyLimit>;
-}
 export declare class WorkspaceConcurrencyLimitsApi extends WorkspaceApi {
     protected routePrefix: string;
     getConcurrencyLimits(filter?: ConcurrencyLimitsFilter): Promise<ConcurrencyLimit[]>;

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

@@ -4,15 +4,6 @@ import { ConcurrencyV2Limit } from '../models/ConcurrencyV2Limit';
 import { ConcurrencyV2Update } from '../models/ConcurrencyV2Update';
 import { ConcurrencyLimitsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceConcurrencyV2LimitsApi {
-    getConcurrencyV2Limit: (concurrencyV2LimitId: string) => Promise<ConcurrencyV2Limit>;
-    getConcurrencyV2Limits: (filter: ConcurrencyLimitsFilter) => Promise<ConcurrencyV2Limit[]>;
-    createConcurrencyV2Limit: (concurrencyV2Limit: ConcurrencyV2Create) => Promise<ConcurrencyV2Limit>;
-    updateConcurrencyV2Limit: (id: string, concurrencyV2Limit: ConcurrencyV2Update) => Promise<ConcurrencyV2Limit>;
-    deleteConcurrencyV2Limit: (concurrencyV2LimitId: string) => Promise<void>;
-    bulkIncrementActiveSlots: (names: string[], slots: number, mode: string) => Promise<ConcurrencyV2ActiveSlots>;
-    bulkDecrementActiveSlots: (names: string[], slots: number, mode: string) => Promise<ConcurrencyV2ActiveSlots>;
-}
 export declare class WorkspaceConcurrencyV2LimitsApi extends WorkspaceApi {
     protected routePrefix: string;
     getConcurrencyV2Limits(filter?: ConcurrencyLimitsFilter): Promise<ConcurrencyV2Limit[]>;

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

@@ -4,17 +4,7 @@ import { DeploymentUpdate } from '../models/DeploymentUpdate';
 import { DeploymentsFilter } from '../models/Filters';
 import { FlowRun } from '../models/FlowRun';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceDeploymentsApi {
-    getDeployment: (deploymentId: string) => Promise<Deployment>;
-    getDeployments: (filter: DeploymentsFilter) => Promise<Deployment[]>;
-    getDeploymentsCount: (filter: DeploymentsFilter) => Promise<number>;
-    createDeploymentFlowRun: (deploymentId: string, request: DeploymentFlowRunCreate) => Promise<FlowRun>;
-    updateDeployment: (deploymentId: string, request: DeploymentUpdate) => Promise<void>;
-    pauseDeployment: (deploymentId: string) => Promise<void>;
-    resumeDeployment: (deploymentId: string) => Promise<void>;
-    deleteDeployment: (deploymentId: string) => Promise<void>;
-}
-export declare class WorkspaceDeploymentsApi extends WorkspaceApi implements IWorkspaceDeploymentsApi {
+export declare class WorkspaceDeploymentsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     getDeployment(deploymentId: string): Promise<Deployment>;

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

@@ -6,19 +6,7 @@ import { FlowRun } from '../models/FlowRun';
 import { RunHistory } from '../models/RunHistory';
 import { WorkspaceApi } from '../services/WorkspaceApi';
 import { Schema, SchemaValues } from '../types/schemas';
-export interface IWorkspaceFlowRunsApi {
-    getFlowRun: (flowRunId: string) => Promise<FlowRun>;
-    getFlowRuns: (filter: FlowRunsFilter) => Promise<FlowRun[]>;
-    getFlowRunsCount: (filter: FlowRunsFilter) => Promise<number>;
-    getFlowRunsHistory: (filter: FlowRunsHistoryFilter) => Promise<RunHistory[]>;
-    getFlowRunsAverageLateness: (filter: FlowRunsFilter) => Promise<number | null>;
-    getFlowRunsGraph: (flowRunId: string) => Promise<RunGraphData>;
-    retryFlowRun: (flowRunId: string) => Promise<void>;
-    setFlowRunState: (flowRunId: string, body: StateUpdate) => Promise<void>;
-    resumeFlowRun: (flowRunId: string, values?: SchemaValues) => Promise<OrchestrationResult>;
-    deleteFlowRun: (flowRunId: string) => Promise<void>;
-}
-export declare class WorkspaceFlowRunsApi extends WorkspaceApi implements IWorkspaceFlowRunsApi {
+export declare class WorkspaceFlowRunsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     getFlowRun(id: string): Promise<FlowRun>;

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

@@ -1,13 +1,7 @@
 import { Flow } from '../models';
 import { FlowsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceFlowsApi {
-    getFlow: (flowId: string) => Promise<Flow>;
-    getFlows: (filter: FlowsFilter) => Promise<Flow[]>;
-    getFlowsCount: (filter: FlowsFilter) => Promise<number>;
-    deleteFlow: (flowId: string) => Promise<void>;
-}
-export declare class WorkspaceFlowsApi extends WorkspaceApi implements IWorkspaceFlowsApi {
+export declare class WorkspaceFlowsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     getFlow(flowId: string): Promise<Flow>;

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

@@ -1,10 +1,7 @@
 import { LogsFilter } from '../models/Filters';
 import { Log } from '../models/Log';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceLogsApi {
-    getLogs: () => Promise<Log[]>;
-}
-export declare class WorkspaceLogsApi extends WorkspaceApi implements IWorkspaceLogsApi {
+export declare class WorkspaceLogsApi extends WorkspaceApi {
     protected routePrefix: string;
     getLogs(filter?: LogsFilter): Promise<Log[]>;
 }

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

@@ -3,14 +3,7 @@ import { Notification } from '../models/Notification';
 import { NotificationCreate } from '../models/NotificationCreate';
 import { NotificationUpdate } from '../models/NotificationUpdate';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceNotificationsApi {
-    getNotification: (notificationId: string) => Promise<Notification>;
-    createNotification: (notification: NotificationCreate) => Promise<Notification>;
-    getNotifications: () => Promise<Notification[]>;
-    updateNotification: (notificationId: string, notification: NotificationUpdate) => Promise<void>;
-    deleteNotification: (notificationId: string) => Promise<void>;
-}
-export declare class WorkspaceNotificationsApi extends WorkspaceApi implements IWorkspaceNotificationsApi {
+export declare class WorkspaceNotificationsApi extends WorkspaceApi {
     protected routePrefix: string;
     getNotification(notificationId: string): Promise<Notification>;
     createNotification(notification: NotificationCreate): Promise<Notification>;

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

@@ -1,13 +1,7 @@
 import { SavedSearchesFilter } from '../models/Filters';
 import { SavedSearch, SavedSearchCreate } from '../models/SavedSearch';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceSavedSearchesApi {
-    getSavedSearches: (filter: SavedSearchesFilter) => Promise<SavedSearch[]>;
-    getSavedSearch: (searchId: string) => Promise<SavedSearch>;
-    createSavedSearch: (search: SavedSearchCreate) => Promise<SavedSearch>;
-    deleteSavedSearch: (searchId: string) => Promise<void>;
-}
-export declare class WorkspaceSavedSearchesApi extends WorkspaceApi implements IWorkspaceSavedSearchesApi {
+export declare class WorkspaceSavedSearchesApi extends WorkspaceApi {
     protected routePrefix: string;
     getSavedSearches(filter?: SavedSearchesFilter): Promise<SavedSearch[]>;
     getSavedSearch(id: string): Promise<SavedSearch>;

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

@@ -3,14 +3,7 @@ import { StateUpdate } from '../models/StateUpdate';
 import { TaskRun } from '../models/TaskRun';
 import { TaskRunHistory } from '../models/TaskRunHistory';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceTaskRunsApi {
-    getTaskRun: (taskRunId: string) => Promise<TaskRun>;
-    getTaskRuns: (filter: TaskRunsFilter) => Promise<TaskRun[]>;
-    getTaskRunsCount: (filter: TaskRunsFilter) => Promise<number>;
-    setTaskRunState: (taskRunId: string, body: StateUpdate) => Promise<void>;
-    deleteTaskRun: (taskRunId: string) => Promise<void>;
-}
-export declare class WorkspaceTaskRunsApi extends WorkspaceApi implements IWorkspaceTaskRunsApi {
+export declare class WorkspaceTaskRunsApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly batcher;
     getTaskRun(taskRunId: string): Promise<TaskRun>;

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

@@ -1,15 +1,6 @@
 import { Variable, VariableCreate, VariableEdit, VariablesFilter } from '../models';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceVariablesApi {
-    getVariables: (filter: VariablesFilter) => Promise<Variable[]>;
-    getVariablesCount: (filter: VariablesFilter) => Promise<number>;
-    getVariable: (variableId: string) => Promise<Variable>;
-    getVariableByName: (variableName: string) => Promise<Variable | null>;
-    createVariable: (body: VariableCreate) => Promise<Variable>;
-    editVariable: (variableId: string, body: VariableEdit) => Promise<Variable>;
-    deleteVariable: (variableId: string) => Promise<void>;
-}
-export declare class WorkspaceVariablesApi extends WorkspaceApi implements IWorkspaceVariablesApi {
+export declare class WorkspaceVariablesApi extends WorkspaceApi {
     protected routePrefix: string;
     getVariable(variableId: string): Promise<Variable>;
     getVariableByName(variableName: string): Promise<Variable | null>;

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

@@ -1,16 +1,7 @@
 import { WorkPoolQueueCreate, WorkPoolQueue, WorkPoolQueueEdit } from '../models';
 import { WorkPoolQueuesFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services';
-export interface IWorkspaceWorkPoolQueuesApi {
-    createWorkPoolQueue: (workPoolName: string, request: WorkPoolQueueCreate) => Promise<WorkPoolQueue>;
-    getWorkPoolQueues: (workPoolName: string, filter: WorkPoolQueuesFilter) => Promise<WorkPoolQueue[]>;
-    getWorkPoolQueueByName: (workPoolName: string, queueName: string) => Promise<WorkPoolQueue>;
-    updateWorkPoolQueue: (workPoolName: string, queueName: string, request: WorkPoolQueueCreate) => Promise<void>;
-    pauseWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
-    resumeWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
-    deleteWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
-}
-export declare class WorkspaceWorkPoolQueuesApi extends WorkspaceApi implements IWorkspaceWorkPoolQueuesApi {
+export declare class WorkspaceWorkPoolQueuesApi extends WorkspaceApi {
     protected routePrefix: string;
     createWorkPoolQueue(workPoolName: string, request: WorkPoolQueueCreate): Promise<WorkPoolQueue>;
     getWorkPoolQueues(workPoolName: string, filter?: WorkPoolQueuesFilter): Promise<WorkPoolQueue[]>;

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

@@ -1,10 +1,7 @@
 import { WorkPoolWorker } from '../models';
 import { WorkPoolWorkersFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services';
-export interface IWorkspaceWorkPoolWorkersApi {
-    getWorkers: (workPoolName: string, filter: WorkPoolWorkersFilter) => Promise<WorkPoolWorker[]>;
-}
-export declare class WorkspaceWorkPoolWorkersApi extends WorkspaceApi implements IWorkspaceWorkPoolWorkersApi {
+export declare class WorkspaceWorkPoolWorkersApi extends WorkspaceApi {
     protected routePrefix: string;
     getWorkers(workPoolName: string, filter?: WorkPoolWorkersFilter): Promise<WorkPoolWorker[]>;
 }

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

@@ -1,18 +1,7 @@
 import { WorkPool, WorkPoolCreate, WorkPoolEdit, WorkerScheduledFlowRun, WorkerScheduledFlowRuns } from '../models';
 import { WorkPoolsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services';
-export interface IWorkspaceWorkPoolsApi {
-    createWorkPool: (request: WorkPoolCreate) => Promise<WorkPool>;
-    getWorkPoolByName: (workPoolName: string) => Promise<WorkPool>;
-    getWorkPools: (filter: WorkPoolsFilter) => Promise<WorkPool[]>;
-    updateWorkPool: (workPoolName: string, request: WorkPoolEdit) => Promise<void>;
-    pauseWorkPool: (workPoolName: string) => Promise<void>;
-    resumeWorkPool: (workPoolName: string) => Promise<void>;
-    deleteWorkPool: (workPoolName: string) => Promise<void>;
-    getWorkPoolScheduledRuns: (workPoolName: string, request: WorkerScheduledFlowRuns) => Promise<WorkerScheduledFlowRun[]>;
-    getWorkPoolLateRuns: (workPoolName: string, request: WorkerScheduledFlowRuns) => Promise<WorkerScheduledFlowRun[]>;
-}
-export declare class WorkspaceWorkPoolsApi extends WorkspaceApi implements IWorkspaceWorkPoolsApi {
+export declare class WorkspaceWorkPoolsApi extends WorkspaceApi {
     protected routePrefix: string;
     createWorkPool(request: WorkPoolCreate): Promise<WorkPool>;
     getWorkPoolByName(name: string): Promise<WorkPool>;

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

@@ -2,19 +2,7 @@ import { FlowRun, WorkQueueCreate, WorkQueueEdit, WorkQueueStatus } from '../mod
 import { WorkQueuesFilter } from '../models/Filters';
 import { WorkQueue } from '../models/WorkQueue';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-export interface IWorkspaceWorkQueuesApi {
-    getWorkQueue: (workQueueId: string) => Promise<WorkQueue>;
-    getWorkQueueByName: (workQueueName: string) => Promise<WorkQueue>;
-    getWorkQueues: (filter: WorkQueuesFilter) => Promise<WorkQueue[]>;
-    createWorkQueue: (request: WorkQueueCreate) => Promise<WorkQueue>;
-    pauseWorkQueue: (workQueueId: string) => Promise<void>;
-    resumeWorkQueue: (workQueueId: string) => Promise<void>;
-    updateWorkQueue: (workQueueId: string, request: WorkQueueEdit) => Promise<void>;
-    deleteWorkQueue: (workQueueId: string) => Promise<void>;
-    getRuns: (workQueueId: string) => Promise<FlowRun[]>;
-    getWorkQueueStatus: (workQueueId: string) => Promise<WorkQueueStatus>;
-}
-export declare class WorkspaceWorkQueuesApi extends WorkspaceApi implements IWorkspaceWorkQueuesApi {
+export declare class WorkspaceWorkQueuesApi extends WorkspaceApi {
     protected routePrefix: string;
     private readonly isBatcher;
     private readonly nameBatcher;

package/dist/types/vite.config.d.ts

@@ -1,2 +1,31 @@
-declare const _default: import("vite").UserConfigFnObject;
+declare const _default: {
+    resolve: {
+        alias: {
+            find: string;
+            replacement: string;
+        }[];
+    };
+    plugins: import("vite").Plugin<any>[];
+    test: {
+        globals: boolean;
+        environment: string;
+    };
+    build: {
+        emptyOutDir: boolean;
+        sourcemap: boolean;
+        lib: {
+            entry: string;
+            name: string;
+        };
+        rollupOptions: {
+            external: string[];
+            output: {
+                exports: string;
+                globals: {
+                    vue: string;
+                };
+            };
+        };
+    };
+};
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@prefecthq/prefect-ui-library",
-    "version": "2.4.19",
+    "version": "2.4.21",
     "private": false,
     "repository": {
         "type": "git",
@@ -15,13 +15,11 @@
         "vue3"
     ],
     "scripts": {
-        "build:demo": "vite build --mode=demo",
         "build": "vue-tsc && tsc-alias && vite build",
         "changelog": "auto-changelog --package --commit-limit 0",
         "dev": "vue-tsc -w & tsc-alias -w & vite build -w --force",
         "lint:fix": "eslint src --fix",
         "lint": "eslint src",
-        "serve": "vite --mode=demo --host",
         "test": "vitest",
         "validate:types": "vue-tsc --noEmit",
         "version": "npm run changelog && git add CHANGELOG.md"
@@ -45,25 +43,25 @@
         "@types/lodash.camelcase": "4.3.9",
         "@types/lodash.debounce": "4.0.9",
         "@types/lodash.merge": "4.6.9",
-        "@types/node": "^20.10.4",
+        "@types/node": "^20.10.6",
         "@types/prismjs": "^1.26.3",
         "@vitejs/plugin-vue": "4.5.2",
         "auto-changelog": "^2.4.0",
         "autoprefixer": "10.4.16",
-        "eslint": "8.55.0",
+        "eslint": "8.56.0",
         "lodash.camelcase": "4.3.0",
         "lodash.debounce": "4.0.8",
         "postcss": "8.4.32",
-        "tailwindcss": "3.3.6",
+        "tailwindcss": "3.4.0",
         "tsc-alias": "1.8.8",
         "typescript": "5.3.3",
-        "vite": "5.0.8",
+        "vite": "5.0.10",
         "vite-svg-loader": "^5.1.0",
         "vitest": "^1.0.4",
         "vue-tsc": "1.8.25"
     },
     "peerDependencies": {
-        "@prefecthq/prefect-design": "^2.2.5",
+        "@prefecthq/prefect-design": "^2.2.9",
         "@prefecthq/vue-charts": "^2.0.3",
         "@prefecthq/vue-compositions": "^1.6.6",
         "vee-validate": "^4.7.0",