@prefecthq/prefect-ui-library 1.0.0 → 1.1.0

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

@@ -23,15 +23,60 @@ export declare class Mapper<T extends Maps> {
     private bindMapper;
 }
 export declare const mapper: Mapper<{
+    FlowFilter: {
+        FlowFilterRequest: MapFunction<import("..").FlowFilter, import("../models/api/Filters").FlowFilterRequest>;
+    };
+    FlowRunFilter: {
+        FlowRunFilterRequest: MapFunction<import("..").FlowRunFilter, import("../models/api/Filters").FlowRunFilterRequest>;
+    };
+    TaskRunFilter: {
+        TaskRunFilterRequest: MapFunction<import("..").TaskRunFilter, import("../models/api/Filters").TaskRunFilterRequest>;
+    };
+    DeploymentFilter: {
+        DeploymentFilterRequest: MapFunction<import("..").DeploymentFilter, import("../models/api/Filters").DeploymentFilterRequest>;
+    };
+    TagFilter: {
+        TagFilterRequest: MapFunction<import("..").TagFilter, import("../models/api/Filters").TagFilterRequest>;
+    };
+    StateFilter: {
+        StateFilterRequest: MapFunction<import("..").StateFilter, import("../models/api/Filters").StateFilterRequest>;
+    };
+    FlowsFilter: {
+        FlowsFilterRequest: MapFunction<import("..").FlowsFilter, import("../models/api/Filters").FlowsFilterRequest>;
+    };
+    FlowRunsFilter: {
+        FlowRunsFilterRequest: MapFunction<import("..").FlowRunsFilter, import("../models/api/Filters").FlowRunsFilterRequest>;
+    };
+    TaskRunsFilter: {
+        TaskRunsFilterRequest: MapFunction<import("..").TaskRunsFilter, import("../models/api/Filters").TaskRunsFilterRequest>;
+    };
+    DeploymentsFilter: {
+        DeploymentsFilterRequest: MapFunction<import("..").DeploymentsFilter, import("../models/api/Filters").DeploymentsFilterRequest>;
+    };
+    BlockDocumentFilter: {
+        BlockDocumentFilterRequest: MapFunction<import("..").BlockDocumentFilter, import("../models/api/Filters").BlockDocumentFilterRequest>;
+    };
+    BlockSchemaFilter: {
+        BlockSchemaFilterRequest: MapFunction<import("..").BlockSchemaFilter, import("../models/api/Filters").BlockSchemaFilterRequest>;
+    };
+    BlockTypeFilter: {
+        BlockTypeFilterRequest: MapFunction<import("..").BlockTypeFilter, import("../models/api/Filters").BlockTypeFilterRequest>;
+    };
+    BlockDocumentsFilter: {
+        BlockDocumentsFilterRequest: MapFunction<import("..").BlockDocumentsFilter, import("../models/api/Filters").BlockDocumentsFilterRequest>;
+    };
+    BlockSchemasFilter: {
+        BlockSchemasFilterRequest: MapFunction<import("..").BlockSchemasFilter, import("../models/api/Filters").BlockSchemasFilterRequest>;
+    };
+    BlockTypesFilter: {
+        BlockTypesFilterRequest: MapFunction<import("..").BlockTypesFilter, import("../models/api/Filters").BlockTypesFilterRequest>;
+    };
     BlockDocument: {
         SelectOption: MapFunction<import("..").BlockDocument, import("@prefecthq/prefect-design").SelectOption>;
     };
     BlockDocumentCreate: {
         BlockDocumentCreateRequest: MapFunction<import("..").BlockDocumentCreate, import("..").BlockDocumentCreateRequest>;
     };
-    BlockDocumentFilter: {
-        BlockDocumentFilterRequest: MapFunction<import("..").BlockDocumentFilter, import("..").BlockDocumentFilterRequest>;
-    };
     BlockDocumentReferencesResponse: {
         BlockDocumentReferences: MapFunction<import("..").BlockDocumentReferencesResponse, import("..").BlockDocumentReferences>;
     };
@@ -41,18 +86,12 @@ export declare const mapper: Mapper<{
     BlockDocumentUpdate: {
         BlockDocumentUpdateRequest: MapFunction<import("..").BlockDocumentUpdate, import("..").BlockDocumentUpdateRequest>;
     };
-    BlockSchemaFilter: {
-        BlockSchemaFilterRequest: MapFunction<import("..").BlockSchemaFilter, import("..").BlockSchemaFilterRequest>;
-    };
     BlockSchemaReferencesResponse: {
         BlockSchemaReferences: MapFunction<import("..").BlockSchemaReferencesResponse, import("..").BlockSchemaReferences>;
     };
     BlockSchemaResponse: {
         BlockSchema: MapFunction<import("..").BlockSchemaResponse, import("..").BlockSchema>;
     };
-    BlockTypeFilter: {
-        BlockTypeFilterRequest: MapFunction<import("..").BlockTypeFilter, import("..").BlockTypeFilterRequest>;
-    };
     BlockTypeResponse: {
         BlockType: MapFunction<import("..").BlockTypeResponse, import("..").BlockType>;
     };
@@ -151,7 +190,7 @@ export declare const mapper: Mapper<{
         SavedSearchCreateRequest: MapFunction<import("..").SavedSearchCreate, import("..").SavedSearchCreateRequest>;
     };
     SavedSearchFilter: {
-        FlowRunFilters: MapFunction<import("..").SavedSearchFilter, import("../types/filter").FlowRunFilters>;
+        FlowRunFilters: MapFunction<import("..").SavedSearchFilter, import("..").FlowRunsFilter>;
     };
     SavedSearchResponse: {
         SavedSearch: MapFunction<import("..").SavedSearchResponse, import("..").SavedSearch>;
@@ -354,10 +393,10 @@ export declare const mapper: Mapper<{
         }>>;
     };
     WorkQueueFilter: {
-        WorkQueueFilterResponse: MapFunction<import("..").WorkQueueFilter, import("..").WorkQueueFilterResponse>;
+        WorkQueueFilterResponse: MapFunction<import("..").WorkQueueFilter, import("../models/api/WorkQueueFilterResponse").WorkQueueFilterResponse>;
     };
     WorkQueueFilterResponse: {
-        WorkQueueFilter: MapFunction<import("..").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
+        WorkQueueFilter: MapFunction<import("../models/api/WorkQueueFilterResponse").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
     };
     WorkQueueHealthPolicyResponse: {
         WorkQueueHealthPolicy: MapFunction<import("..").WorkQueueHealthPolicyResponse, import("..").WorkQueueHealthPolicy>;
@@ -368,6 +407,36 @@ export declare const mapper: Mapper<{
     WorkQueueStatusResponse: {
         WorkQueueStatus: MapFunction<import("..").WorkQueueStatusResponse, import("..").WorkQueueStatus>;
     };
+    WorkPoolsFilter: {
+        WorkPoolsFilterRequest: MapFunction<import("..").WorkPoolsFilter, import("../models/api/Filters").WorkPoolsFilterRequest>;
+    };
+    WorkPoolQueuesFilter: {
+        WorkPoolQueuesFilterRequest: MapFunction<import("..").WorkPoolQueuesFilter, import("../models/api/Filters").WorkPoolQueuesFilterRequest>;
+    };
+    WorkPoolFilter: {
+        WorkPoolFilterRequest: MapFunction<import("..").WorkPoolFilter, import("../models/api/Filters").WorkPoolFilterRequest>;
+    };
+    WorkPoolQueueFilter: {
+        WorkPoolQueueFilterRequest: MapFunction<import("..").WorkPoolQueueFilter, import("../models/api/Filters").WorkPoolQueueFilterRequest>;
+    };
+    FlowRunsHistoryFilter: {
+        FlowRunsHistoryFilterRequest: MapFunction<import("..").FlowRunsHistoryFilter, import("../models/api/Filters").FlowRunsHistoryFilterRequest>;
+    };
+    LogsFilter: {
+        LogsFilterRequest: MapFunction<import("..").LogsFilter, import("../models/api/Filters").LogsFilterRequest>;
+    };
+    NotificationsFilter: {
+        NotificationsFilterRequest: MapFunction<import("..").NotificationsFilter, import("../models/api/Filters").NotificationsFilterRequest>;
+    };
+    SavedSearchesFilter: {
+        SavedSearchesFilterRequest: MapFunction<import("..").SavedSearchesFilter, import("../models/api/Filters").SavedSearchesFilterRequest>;
+    };
+    WorkQueuesFilter: {
+        WorkQueuesFilterRequest: MapFunction<import("..").WorkQueuesFilter, import("../models/api/Filters").WorkQueuesFilterRequest>;
+    };
+    WorkPoolWorkersFilter: {
+        WorkPoolWorkersFilterRequest: MapFunction<import("..").WorkPoolWorkersFilter, import("../models/api/Filters").WorkPoolWorkersFilterRequest>;
+    };
 }>;
 export type MapFunction<S, D> = (this: typeof mapper, source: S) => D;
 export {};

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

@@ -21,7 +21,7 @@ export declare const mocker: Mocker<{
     blockType: MockFunction<import("..").BlockType, [(Partial<import("..").BlockType> | undefined)?]>;
     blockTypeSnippet: MockFunction<string, []>;
     boolean: MockFunction<boolean, []>;
-    char: MockFunction<"a" | "b" | "i" | "p" | "q" | "s" | "u" | "g" | "c" | "d" | "e" | "f" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "r" | "t" | "v" | "w" | "x" | "y" | "z", []>;
+    char: MockFunction<"a" | "b" | "i" | "p" | "q" | "s" | "u" | "g" | "h" | "d" | "w" | "m" | "y" | "e" | "o" | "c" | "f" | "j" | "k" | "l" | "n" | "r" | "t" | "v" | "x" | "z", []>;
     concurrencyLimit: MockFunction<import("..").ConcurrencyLimit, [(Partial<import("..").ConcurrencyLimit> | undefined)?]>;
     createdOrUpdatedBy: MockFunction<import("..").CreatedOrUpdatedBy, [(Partial<import("..").CreatedOrUpdatedBy> | undefined)?]>;
     date: MockFunction<Date, [(Date | undefined)?, (Date | undefined)?]>;
@@ -41,7 +41,7 @@ export declare const mocker: Mocker<{
         height: number;
     }) | undefined)?]>;
     log: MockFunction<import("..").Log, [(Partial<import("..").Log> | undefined)?]>;
-    logLevel: MockFunction<0 | 10 | 20 | 30 | 40 | 50, []>;
+    logLevel: MockFunction<0 | 10 | 20 | 50 | 30 | 40, []>;
     notification: MockFunction<import("..").Notification, [(Partial<import("..").Notification> | undefined)?]>;
     notificationCreate: MockFunction<import("..").NotificationCreate, [(Partial<import("..").NotificationCreate> | undefined)?]>;
     noun: MockFunction<string, []>;

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

@@ -1,9 +1,9 @@
 import { InjectionKey } from 'vue';
+import { FlowRunsFilter } from '../models/Filters';
 import { UiFlowRunHistory } from '../models/UiFlowRunHistory';
 import { Api, ApiRoute } from '../services/Api';
-import { UnionFilters } from '../types/UnionFilters';
 export declare class UiApi extends Api {
     protected route: ApiRoute;
-    getFlowRunHistory(filter: UnionFilters): Promise<UiFlowRunHistory[]>;
+    getFlowRunHistory(filter: FlowRunsFilter): Promise<UiFlowRunHistory[]>;
 }
 export declare const uiApiKey: InjectionKey<UiApi>;

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

@@ -1,11 +1,11 @@
 import { BlockDocument } from '../models/BlockDocument';
 import { BlockDocumentCreate } from '../models/BlockDocumentCreate';
-import { BlockDocumentFilter } from '../models/BlockDocumentFilter';
 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: BlockDocumentFilter) => Promise<BlockDocument[]>;
+    getBlockDocuments: (filter: BlockDocumentsFilter) => Promise<BlockDocument[]>;
     createBlockDocument: (blockDocument: BlockDocumentCreate) => Promise<BlockDocument>;
     updateBlockDocument: (blockDocumentId: string, blockDocument: BlockDocumentUpdate) => Promise<void>;
     deleteBlockDocument: (blockDocumentId: string) => Promise<void>;
@@ -13,7 +13,7 @@ export interface IWorkspaceBlockDocumentsApi {
 export declare class WorkspaceBlockDocumentsApi extends WorkspaceApi implements IWorkspaceBlockDocumentsApi {
     protected routePrefix: string;
     getBlockDocument(blockDocumentId: string): Promise<BlockDocument>;
-    getBlockDocuments(filter?: BlockDocumentFilter): Promise<BlockDocument[]>;
+    getBlockDocuments(filter?: BlockDocumentsFilter): Promise<BlockDocument[]>;
     createBlockDocument(blockDocument: BlockDocumentCreate): Promise<BlockDocument>;
     updateBlockDocument(blockDocumentId: string, blockDocument: BlockDocumentUpdate): Promise<void>;
     deleteBlockDocument(blockDocumentId: string): Promise<void>;

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

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

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

@@ -1,17 +1,17 @@
 import { BlockDocument } from '../models/BlockDocument';
 import { BlockType } from '../models/BlockType';
-import { BlockTypeFilter } from '../models/BlockTypeFilter';
+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: BlockTypeFilter) => Promise<BlockType[]>;
+    getBlockTypes: (filter: BlockTypesFilter) => Promise<BlockType[]>;
     getBlockDocumentsByBlockTypeSlug: (blockTypeSlug: string) => Promise<BlockDocument[]>;
 }
 export declare class WorkspaceBlockTypesApi extends WorkspaceApi implements IWorkspaceBlockTypesApi {
     protected routePrefix: string;
     getBlockType(blockTypeId: string): Promise<BlockType>;
     getBlockTypeBySlug(blockTypeSlug: string): Promise<BlockType>;
-    getBlockTypes(filter?: BlockTypeFilter): Promise<BlockType[]>;
+    getBlockTypes(filter?: BlockTypesFilter): Promise<BlockType[]>;
     getBlockDocumentsByBlockTypeSlug(blockTypeSlug: string): Promise<BlockDocument[]>;
 }

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

@@ -1,6 +1,6 @@
 import { ConcurrencyLimit } from '../models/ConcurrencyLimit';
 import { ConcurrencyLimitCreate } from '../models/ConcurrencyLimitCreate';
-import { ConcurrencyLimitsFilter } from '../models/ConcurrencyLimitsFilter';
+import { ConcurrencyLimitsFilter } from '../models/Filters';
 import { WorkspaceApi } from '../services/WorkspaceApi';
 export interface IWorkspaceConcurrencyLimitsApi {
     getConcurrencyLimit: (concurrencyLimitId: string) => Promise<ConcurrencyLimit>;

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

@@ -1,13 +1,13 @@
 import { Deployment } from '../models/Deployment';
 import { DeploymentFlowRunCreate } from '../models/DeploymentFlowRunCreate';
 import { DeploymentUpdate } from '../models/DeploymentUpdate';
+import { DeploymentsFilter } from '../models/Filters';
 import { FlowRun } from '../models/FlowRun';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-import { UnionFilters } from '../types/UnionFilters';
 export interface IWorkspaceDeploymentsApi {
     getDeployment: (deploymentId: string) => Promise<Deployment>;
-    getDeployments: (filter: UnionFilters) => Promise<Deployment[]>;
-    getDeploymentsCount: (filter: UnionFilters) => Promise<number>;
+    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>;
@@ -17,8 +17,8 @@ export interface IWorkspaceDeploymentsApi {
 export declare class WorkspaceDeploymentsApi extends WorkspaceApi implements IWorkspaceDeploymentsApi {
     protected routePrefix: string;
     getDeployment(deploymentId: string): Promise<Deployment>;
-    getDeployments(filter?: UnionFilters): Promise<Deployment[]>;
-    getDeploymentsCount(filter?: UnionFilters): Promise<number>;
+    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(id: string): Promise<void>;

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

@@ -1,13 +1,13 @@
 import { StateUpdate, TimelineNode } from '../models';
+import { FlowRunsFilter, FlowRunsHistoryFilter } from '../models/Filters';
 import { FlowRun } from '../models/FlowRun';
 import { GraphNode } from '../models/GraphNode';
 import { RunHistory } from '../models/RunHistory';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-import { FlowRunsHistoryFilter, UnionFilters } from '../types/UnionFilters';
 export interface IWorkspaceFlowRunsApi {
     getFlowRun: (flowRunId: string) => Promise<FlowRun>;
-    getFlowRuns: (filter: UnionFilters) => Promise<FlowRun[]>;
-    getFlowRunsCount: (filter: UnionFilters) => Promise<number>;
+    getFlowRuns: (filter: FlowRunsFilter) => Promise<FlowRun[]>;
+    getFlowRunsCount: (filter: FlowRunsFilter) => Promise<number>;
     getFlowRunsHistory: (filter: FlowRunsHistoryFilter) => Promise<RunHistory[]>;
     getFlowRunsGraph: (flowRunId: string) => Promise<GraphNode[]>;
     getFlowRunsTimeline: (flowRunId: string) => Promise<TimelineNode[]>;
@@ -20,8 +20,8 @@ export declare class WorkspaceFlowRunsApi extends WorkspaceApi implements IWorks
     protected routePrefix: string;
     private readonly batcher;
     getFlowRun(id: string): Promise<FlowRun>;
-    getFlowRuns(filter?: UnionFilters): Promise<FlowRun[]>;
-    getFlowRunsCount(filter?: UnionFilters): Promise<number>;
+    getFlowRuns(filter?: FlowRunsFilter): Promise<FlowRun[]>;
+    getFlowRunsCount(filter?: FlowRunsFilter): Promise<number>;
     getFlowRunsHistory(filter: FlowRunsHistoryFilter): Promise<RunHistory[]>;
     getFlowRunsGraph(flowRunId: string): Promise<GraphNode[]>;
     getFlowRunsTimeline(id: string): Promise<TimelineNode[]>;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { NotificationFilter } from '../models/api/NotificationFilter';
+import { NotificationsFilter } from '../models/Filters';
 import { Notification } from '../models/Notification';
 import { NotificationCreate } from '../models/NotificationCreate';
 import { NotificationUpdate } from '../models/NotificationUpdate';
@@ -7,7 +7,7 @@ export declare class WorkspaceNotificationsApi extends WorkspaceApi {
     protected routePrefix: string;
     getNotification(id: string): Promise<Notification>;
     createNotification(notification: NotificationCreate): Promise<Notification>;
-    getNotifications(filter?: NotificationFilter): Promise<Notification[]>;
+    getNotifications(filter?: NotificationsFilter): Promise<Notification[]>;
     updateNotification(id: string, notification: NotificationUpdate): Promise<void>;
     deleteNotification(id: string): Promise<void>;
 }

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

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

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

@@ -1,19 +1,19 @@
+import { TaskRunsFilter } from '../models/Filters';
 import { StateUpdate } from '../models/StateUpdate';
 import { TaskRun } from '../models/TaskRun';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-import { UnionFilters } from '../types/UnionFilters';
 export interface IWorkspaceTaskRunsApi {
     getTaskRun: (taskRunId: string) => Promise<TaskRun>;
-    getTaskRuns: (filter: UnionFilters) => Promise<TaskRun[]>;
-    getTaskRunsCount: (filter: UnionFilters) => Promise<number>;
+    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 {
     protected routePrefix: string;
     getTaskRun(id: string): Promise<TaskRun>;
-    getTaskRuns(filter?: UnionFilters): Promise<TaskRun[]>;
-    getTaskRunsCount(filter?: UnionFilters): Promise<number>;
+    getTaskRuns(filter?: TaskRunsFilter): Promise<TaskRun[]>;
+    getTaskRunsCount(filter?: TaskRunsFilter): Promise<number>;
     setTaskRunState(id: string, body: StateUpdate): Promise<void>;
     deleteTaskRun(taskRunId: string): Promise<void>;
 }

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

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

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

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

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

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

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

@@ -1,11 +1,11 @@
 import { FlowRun, WorkQueueCreate, WorkQueueEdit, WorkQueueStatus } from '../models';
+import { WorkQueuesFilter } from '../models/Filters';
 import { WorkQueue } from '../models/WorkQueue';
 import { WorkspaceApi } from '../services/WorkspaceApi';
-import { PaginatedFilter } from '../types/UnionFilters';
 export interface IWorkspaceWorkQueuesApi {
     getWorkQueue: (workQueueId: string) => Promise<WorkQueue>;
     getWorkQueueByName: (workQueueName: string) => Promise<WorkQueue>;
-    getWorkQueues: (filter: PaginatedFilter) => Promise<WorkQueue[]>;
+    getWorkQueues: (filter: WorkQueuesFilter) => Promise<WorkQueue[]>;
     createWorkQueue: (request: WorkQueueCreate) => Promise<WorkQueue>;
     pauseWorkQueue: (workQueueId: string) => Promise<void>;
     resumeWorkQueue: (workQueueId: string) => Promise<void>;
@@ -18,7 +18,7 @@ export declare class WorkspaceWorkQueuesApi extends WorkspaceApi implements IWor
     protected routePrefix: string;
     getWorkQueue(id: string): Promise<WorkQueue>;
     getWorkQueueByName(name: string): Promise<WorkQueue>;
-    getWorkQueues(filter: PaginatedFilter): Promise<WorkQueue[]>;
+    getWorkQueues(filter: WorkQueuesFilter): Promise<WorkQueue[]>;
     createWorkQueue(request: WorkQueueCreate): Promise<WorkQueue>;
     pauseWorkQueue(id: string): Promise<void>;
     resumeWorkQueue(id: string): Promise<void>;

package/dist/types/src/types/SortOptionTypes.d.ts

@@ -1,34 +1,47 @@
 import { Ref } from 'vue';
-declare const flowSortValues: readonly ["CREATED_DESC", "UPDATED_DESC", "NAME_DESC", "NAME_ASC"];
+export declare const flowSortValues: readonly ["CREATED_DESC", "UPDATED_DESC", "NAME_DESC", "NAME_ASC"];
 export type FlowSortValues = typeof flowSortValues[number];
+export declare const defaultFlowSort: FlowSortValues;
 export declare function isFlowSortValue(value: unknown): value is FlowSortValues;
 export declare function isFlowSortValue(value: Ref<unknown>): value is Ref<FlowSortValues>;
 export declare const flowSortOptions: {
     label: string;
     value: string;
 }[];
-declare const deploymentSortValues: readonly ["CREATED_DESC", "UPDATED_DESC", "NAME_DESC", "NAME_ASC"];
+export declare const deploymentSortValues: readonly ["CREATED_DESC", "UPDATED_DESC", "NAME_DESC", "NAME_ASC"];
 export type DeploymentSortValues = typeof deploymentSortValues[number];
+export declare const defaultDeploymentSort: DeploymentSortValues;
 export declare function isDeploymentSortValue(value: unknown): value is DeploymentSortValues;
 export declare function isDeploymentSortValue(value: Ref<unknown>): value is Ref<DeploymentSortValues>;
 export declare const deploymentSortOptions: {
     label: string;
     value: string;
 }[];
-declare const flowRunSortValues: readonly ["CREATED_DESC", "NAME_DESC", "NAME_ASC", "EXPECTED_START_TIME_DESC", "EXPECTED_START_TIME_ASC", "NEXT_SCHEDULED_START_TIME_ASC", "START_TIME_DESC", "START_TIME_ASC"];
+export declare const flowRunSortValues: readonly ["CREATED_DESC", "NAME_DESC", "NAME_ASC", "EXPECTED_START_TIME_DESC", "EXPECTED_START_TIME_ASC", "NEXT_SCHEDULED_START_TIME_ASC", "START_TIME_DESC", "START_TIME_ASC"];
 export type FlowRunSortValues = typeof flowRunSortValues[number];
+export declare const defaultFlowRunSort: FlowRunSortValues;
 export declare function isFlowRunSortValue(value: unknown): value is FlowRunSortValues;
 export declare function isFlowRunSortValue(value: Ref<unknown>): value is Ref<FlowRunSortValues>;
 export type FlowRunSortOptions = {
     label: string;
     value: FlowRunSortValues;
 }[];
-declare const taskRunSortValues: readonly ["ID_DESC", "EXPECTED_START_TIME_ASC", "EXPECTED_START_TIME_DESC", "NEXT_SCHEDULED_START_TIME_ASC", "END_TIME_DESC"];
+export declare const taskRunSortValues: readonly ["ID_DESC", "EXPECTED_START_TIME_ASC", "EXPECTED_START_TIME_DESC", "NEXT_SCHEDULED_START_TIME_ASC", "END_TIME_DESC"];
 export type TaskRunSortValues = typeof taskRunSortValues[number];
+export declare const defaultTaskRunSort: TaskRunSortValues;
 export declare function isTaskRunSortValue(value: unknown): value is TaskRunSortValues;
 export declare function isTaskRunSortValue(value: Ref<unknown>): value is Ref<TaskRunSortValues>;
 export type TaskRunSortOptions = {
     label: string;
     value: TaskRunSortValues;
 }[];
+declare const logSortValues: string[];
+export type LogSortValues = typeof logSortValues[number];
+export declare const defaultLogSort: LogSortValues;
+export declare function isLogSortValue(value: unknown): value is LogSortValues;
+export declare function isLogSortValue(value: Ref<unknown>): value is Ref<LogSortValues>;
+export type LogSortOptions = {
+    label: string;
+    value: LogSortValues;
+}[];
 export {};

package/dist/types/src/types/any.d.ts

@@ -0,0 +1,2 @@
+export type AnyRecord = Record<PropertyKey, unknown>;
+export type AnyArray = unknown[];

package/dist/types/src/types/debug.d.ts

@@ -0,0 +1,6 @@
+export type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type ExpandRecursively<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;

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

@@ -9,6 +9,5 @@ export * from './SortOptionTypes';
 export * from './states';
 export * from './tabs';
 export * from './tailwind';
-export * from './UnionFilters';
 export * from './utilities';
 export * from './schemas';

package/dist/types/src/types/reactivity.d.ts

@@ -1,2 +1,6 @@
 import { Ref } from 'vue';
+import { AnyArray, AnyRecord } from '../types/any';
 export type MaybeRef<T> = Ref<T> | T;
+export type MaybeReactive<T extends object> = T | {
+    [P in keyof T]: [T[P]] extends [object | undefined] ? [T[P]] extends [AnyRecord | undefined] ? MaybeRef<Exclude<T[P], undefined>> | MaybeReactive<Exclude<T[P], undefined>> : [T[P]] extends [AnyArray | undefined] ? MaybeRef<Exclude<T[P], undefined>> : MaybeRef<T[P]> : MaybeRef<T[P]>;
+};

package/dist/types/src/utilities/object.d.ts

@@ -2,8 +2,20 @@ export declare function flip<K extends string, V extends string>(obj: Record<K,
 export declare function omit<T extends Record<string, unknown>, K extends (keyof T)[]>(source: T, keys: K): Omit<T, K[number]>;
 export declare function clone<T>(source: T): T;
 export declare function hasProperty<T extends Record<string | symbol, unknown>>(needle: T, property: unknown): property is keyof T;
-export type MapEntriesCallback<K, V, R> = (key: K, value: V) => R;
-export declare function mapEntries<K extends string | number | symbol, V, R>(object: Record<K, V>, callback: MapEntriesCallback<K, V, R>): Record<K, R>;
+export type ObjectKey = string | number | symbol;
+export type MapKeysCallback<PreviousKey extends ObjectKey, Value, NewKey extends ObjectKey> = (key: PreviousKey, value: Value) => NewKey;
+export declare function mapKeys<K extends ObjectKey, V, Key extends ObjectKey>(object: Record<K, V>, callback: MapKeysCallback<K, V, Key>): Record<Key, V>;
+export type MapValuesCallback<Key extends ObjectKey, PreviousValue, NewValue> = (key: Key, value: PreviousValue) => NewValue;
+export declare function mapValues<Key extends ObjectKey, PreviousValue, NewValue>(object: Record<Key, PreviousValue>, callback: MapValuesCallback<Key, PreviousValue, NewValue>): Record<Key, NewValue>;
+export type MapEntriesCallback<PreviousKey extends ObjectKey, PreviousValue, NewKey extends ObjectKey, NewValue> = (key: PreviousKey, value: PreviousValue) => [NewKey, NewValue];
+export declare function mapEntries<PreviousKey extends ObjectKey, PreviousValue, NewKey extends ObjectKey, NewValue>(object: Partial<Record<PreviousKey, PreviousValue>>, callback: MapEntriesCallback<PreviousKey, PreviousValue, NewKey, NewValue>): Partial<Record<NewKey, NewValue>>;
 export declare function isEmptyObject(value: unknown): value is Record<string, never>;
 export declare function isTypeRequired<T extends Record<string | number | symbol, unknown>>(value: Partial<T>): value is Required<T>;
 export declare function hasString(obj: Record<string | number | symbol, unknown>, str: string): boolean;
+export declare function isRecord(item: unknown): item is Record<PropertyKey, unknown>;
+export declare function merge<T extends Record<PropertyKey, unknown>>(target: T, ...sources: T[]): T;
+type EmptyObjectsRemoved<T extends Record<PropertyKey, unknown>> = {
+    [P in keyof T]: T[P] extends Record<PropertyKey, unknown> ? EmptyObjectsRemoved<T[P]> | undefined : T[P];
+};
+export declare function removeEmptyObjects<T extends Record<PropertyKey, unknown>>(input: T): EmptyObjectsRemoved<T>;
+export {};

package/dist/{viewport.es-a6380c41-3517fd0a.mjs → viewport.es-a6380c41-d7ba6e04.mjs}

@@ -1,9 +1,9 @@
-import { h as c, q as b, L as O, E as k } from "./index-5e1667e6.mjs";
+import { h as c, q as b, L as O, E as k } from "./index-c7e44121.mjs";
 import "vue";
 import "@prefecthq/vue-compositions";
 import "@prefecthq/prefect-design";
-import "vue-router";
 import "vee-validate";
+import "vue-router";
 class d {
   constructor(t) {
     this.parent = t, this.paused = !1;
@@ -1534,4 +1534,4 @@ export {
   C as Viewport,
   $ as Wheel
 };
-//# sourceMappingURL=viewport.es-a6380c41-3517fd0a.mjs.map
+//# sourceMappingURL=viewport.es-a6380c41-d7ba6e04.mjs.map