@prefecthq/prefect-ui-library 1.0.0 → 1.1.1

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

@@ -1,13 +1,58 @@
 export declare const maps: {
+    FlowFilter: {
+        FlowFilterRequest: import("..").MapFunction<import("..").FlowFilter, import("../models/api/Filters").FlowFilterRequest>;
+    };
+    FlowRunFilter: {
+        FlowRunFilterRequest: import("..").MapFunction<import("..").FlowRunFilter, import("../models/api/Filters").FlowRunFilterRequest>;
+    };
+    TaskRunFilter: {
+        TaskRunFilterRequest: import("..").MapFunction<import("..").TaskRunFilter, import("../models/api/Filters").TaskRunFilterRequest>;
+    };
+    DeploymentFilter: {
+        DeploymentFilterRequest: import("..").MapFunction<import("..").DeploymentFilter, import("../models/api/Filters").DeploymentFilterRequest>;
+    };
+    TagFilter: {
+        TagFilterRequest: import("..").MapFunction<import("..").TagFilter, import("../models/api/Filters").TagFilterRequest>;
+    };
+    StateFilter: {
+        StateFilterRequest: import("..").MapFunction<import("..").StateFilter, import("../models/api/Filters").StateFilterRequest>;
+    };
+    FlowsFilter: {
+        FlowsFilterRequest: import("..").MapFunction<import("..").FlowsFilter, import("../models/api/Filters").FlowsFilterRequest>;
+    };
+    FlowRunsFilter: {
+        FlowRunsFilterRequest: import("..").MapFunction<import("..").FlowRunsFilter, import("../models/api/Filters").FlowRunsFilterRequest>;
+    };
+    TaskRunsFilter: {
+        TaskRunsFilterRequest: import("..").MapFunction<import("..").TaskRunsFilter, import("../models/api/Filters").TaskRunsFilterRequest>;
+    };
+    DeploymentsFilter: {
+        DeploymentsFilterRequest: import("..").MapFunction<import("..").DeploymentsFilter, import("../models/api/Filters").DeploymentsFilterRequest>;
+    };
+    BlockDocumentFilter: {
+        BlockDocumentFilterRequest: import("..").MapFunction<import("..").BlockDocumentFilter, import("../models/api/Filters").BlockDocumentFilterRequest>;
+    };
+    BlockSchemaFilter: {
+        BlockSchemaFilterRequest: import("..").MapFunction<import("..").BlockSchemaFilter, import("../models/api/Filters").BlockSchemaFilterRequest>;
+    };
+    BlockTypeFilter: {
+        BlockTypeFilterRequest: import("..").MapFunction<import("..").BlockTypeFilter, import("../models/api/Filters").BlockTypeFilterRequest>;
+    };
+    BlockDocumentsFilter: {
+        BlockDocumentsFilterRequest: import("..").MapFunction<import("..").BlockDocumentsFilter, import("../models/api/Filters").BlockDocumentsFilterRequest>;
+    };
+    BlockSchemasFilter: {
+        BlockSchemasFilterRequest: import("..").MapFunction<import("..").BlockSchemasFilter, import("../models/api/Filters").BlockSchemasFilterRequest>;
+    };
+    BlockTypesFilter: {
+        BlockTypesFilterRequest: import("..").MapFunction<import("..").BlockTypesFilter, import("../models/api/Filters").BlockTypesFilterRequest>;
+    };
     BlockDocument: {
         SelectOption: import("..").MapFunction<import("..").BlockDocument, import("@prefecthq/prefect-design").SelectOption>;
     };
     BlockDocumentCreate: {
         BlockDocumentCreateRequest: import("..").MapFunction<import("..").BlockDocumentCreate, import("..").BlockDocumentCreateRequest>;
     };
-    BlockDocumentFilter: {
-        BlockDocumentFilterRequest: import("..").MapFunction<import("..").BlockDocumentFilter, import("..").BlockDocumentFilterRequest>;
-    };
     BlockDocumentReferencesResponse: {
         BlockDocumentReferences: import("..").MapFunction<import("..").BlockDocumentReferencesResponse, import("..").BlockDocumentReferences>;
     };
@@ -17,18 +62,12 @@ export declare const maps: {
     BlockDocumentUpdate: {
         BlockDocumentUpdateRequest: import("..").MapFunction<import("..").BlockDocumentUpdate, import("..").BlockDocumentUpdateRequest>;
     };
-    BlockSchemaFilter: {
-        BlockSchemaFilterRequest: import("..").MapFunction<import("..").BlockSchemaFilter, import("..").BlockSchemaFilterRequest>;
-    };
     BlockSchemaReferencesResponse: {
         BlockSchemaReferences: import("..").MapFunction<import("..").BlockSchemaReferencesResponse, import("..").BlockSchemaReferences>;
     };
     BlockSchemaResponse: {
         BlockSchema: import("..").MapFunction<import("..").BlockSchemaResponse, import("..").BlockSchema>;
     };
-    BlockTypeFilter: {
-        BlockTypeFilterRequest: import("..").MapFunction<import("..").BlockTypeFilter, import("..").BlockTypeFilterRequest>;
-    };
     BlockTypeResponse: {
         BlockType: import("..").MapFunction<import("..").BlockTypeResponse, import("..").BlockType>;
     };
@@ -127,7 +166,7 @@ export declare const maps: {
         SavedSearchCreateRequest: import("..").MapFunction<import("..").SavedSearchCreate, import("..").SavedSearchCreateRequest>;
     };
     SavedSearchFilter: {
-        FlowRunFilters: import("..").MapFunction<import("..").SavedSearchFilter, import("../types/filter").FlowRunFilters>;
+        FlowRunFilters: import("..").MapFunction<import("..").SavedSearchFilter, import("..").FlowRunsFilter>;
     };
     SavedSearchResponse: {
         SavedSearch: import("..").MapFunction<import("..").SavedSearchResponse, import("..").SavedSearch>;
@@ -330,10 +369,10 @@ export declare const maps: {
         }>>;
     };
     WorkQueueFilter: {
-        WorkQueueFilterResponse: import("..").MapFunction<import("..").WorkQueueFilter, import("..").WorkQueueFilterResponse>;
+        WorkQueueFilterResponse: import("..").MapFunction<import("..").WorkQueueFilter, import("../models/api/WorkQueueFilterResponse").WorkQueueFilterResponse>;
     };
     WorkQueueFilterResponse: {
-        WorkQueueFilter: import("..").MapFunction<import("..").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
+        WorkQueueFilter: import("..").MapFunction<import("../models/api/WorkQueueFilterResponse").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
     };
     WorkQueueHealthPolicyResponse: {
         WorkQueueHealthPolicy: import("..").MapFunction<import("..").WorkQueueHealthPolicyResponse, import("..").WorkQueueHealthPolicy>;
@@ -344,4 +383,34 @@ export declare const maps: {
     WorkQueueStatusResponse: {
         WorkQueueStatus: import("..").MapFunction<import("..").WorkQueueStatusResponse, import("..").WorkQueueStatus>;
     };
+    WorkPoolsFilter: {
+        WorkPoolsFilterRequest: import("..").MapFunction<import("..").WorkPoolsFilter, import("../models/api/Filters").WorkPoolsFilterRequest>;
+    };
+    WorkPoolQueuesFilter: {
+        WorkPoolQueuesFilterRequest: import("..").MapFunction<import("..").WorkPoolQueuesFilter, import("../models/api/Filters").WorkPoolQueuesFilterRequest>;
+    };
+    WorkPoolFilter: {
+        WorkPoolFilterRequest: import("..").MapFunction<import("..").WorkPoolFilter, import("../models/api/Filters").WorkPoolFilterRequest>;
+    };
+    WorkPoolQueueFilter: {
+        WorkPoolQueueFilterRequest: import("..").MapFunction<import("..").WorkPoolQueueFilter, import("../models/api/Filters").WorkPoolQueueFilterRequest>;
+    };
+    FlowRunsHistoryFilter: {
+        FlowRunsHistoryFilterRequest: import("..").MapFunction<import("..").FlowRunsHistoryFilter, import("../models/api/Filters").FlowRunsHistoryFilterRequest>;
+    };
+    LogsFilter: {
+        LogsFilterRequest: import("..").MapFunction<import("..").LogsFilter, import("../models/api/Filters").LogsFilterRequest>;
+    };
+    NotificationsFilter: {
+        NotificationsFilterRequest: import("..").MapFunction<import("..").NotificationsFilter, import("../models/api/Filters").NotificationsFilterRequest>;
+    };
+    SavedSearchesFilter: {
+        SavedSearchesFilterRequest: import("..").MapFunction<import("..").SavedSearchesFilter, import("../models/api/Filters").SavedSearchesFilterRequest>;
+    };
+    WorkQueuesFilter: {
+        WorkQueuesFilterRequest: import("..").MapFunction<import("..").WorkQueuesFilter, import("../models/api/Filters").WorkQueuesFilterRequest>;
+    };
+    WorkPoolWorkersFilter: {
+        WorkPoolWorkersFilterRequest: import("..").MapFunction<import("..").WorkPoolWorkersFilter, import("../models/api/Filters").WorkPoolWorkersFilterRequest>;
+    };
 };

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

@@ -8,7 +8,7 @@ export declare const mocks: {
     blockType: import("..").MockFunction<import("..").BlockType, [(Partial<import("..").BlockType> | undefined)?]>;
     blockTypeSnippet: import("..").MockFunction<string, []>;
     boolean: import("..").MockFunction<boolean, []>;
-    char: import("..").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: import("..").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: import("..").MockFunction<import("..").ConcurrencyLimit, [(Partial<import("..").ConcurrencyLimit> | undefined)?]>;
     createdOrUpdatedBy: import("..").MockFunction<import("..").CreatedOrUpdatedBy, [(Partial<import("..").CreatedOrUpdatedBy> | undefined)?]>;
     date: import("..").MockFunction<Date, [(Date | undefined)?, (Date | undefined)?]>;
@@ -28,7 +28,7 @@ export declare const mocks: {
         height: number;
     }) | undefined)?]>;
     log: import("..").MockFunction<import("..").Log, [(Partial<import("..").Log> | undefined)?]>;
-    logLevel: import("..").MockFunction<0 | 10 | 20 | 30 | 40 | 50, []>;
+    logLevel: import("..").MockFunction<0 | 10 | 20 | 50 | 30 | 40, []>;
     notification: import("..").MockFunction<import("..").Notification, [(Partial<import("..").Notification> | undefined)?]>;
     notificationCreate: import("..").MockFunction<import("..").NotificationCreate, [(Partial<import("..").NotificationCreate> | undefined)?]>;
     noun: import("..").MockFunction<string, []>;

package/dist/types/src/models/Filters.d.ts

@@ -0,0 +1,193 @@
+import { FlowSortValues, FlowRunSortValues, TaskRunSortValues, DeploymentSortValues, LogSortValues } from '../types';
+export type Operation = 'and' | 'or';
+export declare function isOperation(value: string): value is Operation;
+export type TagFilter = {
+    operator?: Operation;
+    name?: string[];
+    isNull?: boolean;
+};
+export type StateFilter = {
+    operator?: Operation;
+    type?: string[];
+    name?: string[];
+};
+export type FlowFilter = {
+    operator?: Operation;
+    id?: string[];
+    name?: string[];
+    nameLike?: string;
+    tags?: TagFilter;
+};
+export type FlowRunFilter = {
+    operator?: Operation;
+    id?: string[];
+    notId?: string[];
+    name?: string[];
+    nameLike?: string;
+    tags?: TagFilter;
+    deploymentIdOperator?: Operation;
+    deploymentId?: string[];
+    deploymentIdNull?: boolean;
+    workQueueNameOperator?: Operation;
+    workQueueName?: string[];
+    workQueueNameIsNull?: boolean;
+    state?: StateFilter;
+    flowVersion?: string[];
+    expectedStartTimeBefore?: Date;
+    expectedStartTimeAfter?: Date;
+    nextExpectedStartTimeBefore?: Date;
+    nextExpectedStartTimeAfter?: Date;
+    startTimeBefore?: Date;
+    startTimeAfter?: Date;
+    startTimeNull?: boolean;
+    parentTaskRunIdOperator?: Operation;
+    parentTaskRunId?: string[];
+    parentTaskRunIdNull?: boolean;
+};
+export type TaskRunFilter = {
+    operator?: Operation;
+    id?: string[];
+    name?: string[];
+    nameLike?: string;
+    tags?: TagFilter;
+    state?: StateFilter;
+    startTimeBefore?: Date;
+    startTimeAfter?: Date;
+    startTimeNull?: boolean;
+    subFlowRunsExist?: boolean;
+};
+export type DeploymentFilter = {
+    id?: string[];
+    isScheduleActive?: boolean;
+    name?: string[];
+    nameLike?: string;
+    operator?: Operation;
+    tags?: TagFilter;
+    workQueueName?: string[];
+};
+export type WorkPoolFilter = {
+    operator?: Operation;
+    id?: string[];
+    name?: string[];
+    type?: string[];
+};
+export type WorkPoolQueueFilter = {
+    operator?: Operation;
+    id?: string[];
+    name?: string[];
+};
+export type UnionFilterSort = FlowSortValues | FlowRunSortValues | TaskRunSortValues | DeploymentSortValues;
+export type UnionFilter<T extends UnionFilterSort = UnionFilterSort> = {
+    flows?: FlowFilter;
+    flowRuns?: FlowRunFilter;
+    taskRuns?: TaskRunFilter;
+    deployments?: DeploymentFilter;
+    workPools?: WorkPoolFilter;
+    workPoolQueues?: WorkPoolQueueFilter;
+    sort?: T;
+    offset?: number;
+    limit?: number;
+};
+export type BlockTypeFilter = {
+    nameLike?: string;
+    slug?: string[];
+};
+export type BlockSchemaFilter = {
+    operator?: Operation;
+    id?: string[];
+    blockTypeId?: string[];
+    blockCapabilities?: string[];
+    version?: string[];
+};
+export type BlockDocumentFilter = {
+    operator?: Operation;
+    id?: string[];
+    isAnonymous?: boolean;
+    blockTypeId?: string[];
+    name?: string[];
+};
+export type FlowsFilter = UnionFilter<FlowSortValues>;
+export type FlowRunsFilter = UnionFilter<FlowRunSortValues>;
+export type TaskRunsFilter = UnionFilter<TaskRunSortValues>;
+export type DeploymentsFilter = UnionFilter<DeploymentSortValues>;
+export type FlowRunsHistoryFilter = FlowRunsFilter & {
+    historyStart: Date;
+    historyEnd: Date;
+    historyIntervalSeconds: number;
+};
+export type NotificationsFilter = {
+    notification?: {
+        isActive?: boolean;
+    };
+    offset?: number;
+    limit?: number;
+};
+export type SavedSearchesFilter = {
+    offset?: number;
+    limit?: number;
+};
+export type LogsFilter = {
+    logs?: {
+        operator?: Operation;
+        levelGreaterThan?: number;
+        levelLessThan?: number;
+        timestampBefore?: Date;
+        timestampAfter?: Date;
+        flowRunId?: string[];
+        taskRunId?: string[];
+    };
+    sort?: LogSortValues;
+    offset?: number;
+    limit?: number;
+};
+export type ConcurrencyLimitsFilter = {
+    offset?: number;
+    limit?: number;
+};
+export type BlockTypesFilter = {
+    blockTypes?: BlockTypeFilter;
+    blockSchemas?: BlockSchemaFilter;
+    offset?: number;
+    limit?: number;
+};
+export type BlockSchemasFilter = {
+    blockSchemas?: BlockSchemaFilter;
+    offset?: number;
+    limit?: number;
+};
+export type BlockDocumentsFilter = {
+    blockDocuments?: BlockDocumentFilter;
+    blockTypes?: BlockTypeFilter;
+    blockSchemas?: BlockSchemaFilter;
+    includeSecrets?: boolean;
+    offset?: number;
+    limit?: number;
+};
+export type WorkQueuesFilter = {
+    workQueues?: {
+        operator?: Operation;
+        name?: string[];
+        nameStartsWith: string[];
+    };
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolsFilter = {
+    workPools?: WorkPoolFilter;
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolQueuesFilter = {
+    workPools?: WorkPoolFilter;
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolWorkersFilter = {
+    workers?: {
+        operator?: Operation;
+        lastHeartbeatTimeBefore?: Date;
+        lastHeartbeatTimeAfter?: Date;
+    };
+    limit?: number;
+    offset?: number;
+};

package/dist/types/src/models/api/Filters.d.ts

@@ -0,0 +1,211 @@
+import { DeploymentSortValues, FlowRunSortValues, FlowSortValues, LogSortValues, TaskRunSortValues } from '../../types/SortOptionTypes';
+/** A list where results will be returned only if they match all the values in the list */
+export type All = {
+    all_?: string[];
+};
+/** A list where results will be returned if any of the values are included in the list */
+export type Any = {
+    any_?: string[];
+};
+export type Like = {
+    like_?: string;
+};
+export type StartsWith = {
+    startswith_?: string[];
+};
+/** A list where results will be returned if values don't match any in the list */
+export type NotAny = {
+    not_any_?: string[];
+};
+/** Matches on boolean equality */
+export type Equals = {
+    eq_?: boolean;
+};
+/** Matches on boolean equality */
+export type Exists = {
+    exists_?: boolean;
+};
+/** If true, returns results whose key is null */
+export type IsNull = {
+    is_null_?: boolean;
+};
+/** A date-time string to include results starting at or before this time */
+export type Before = {
+    before_?: string;
+};
+export type After = {
+    after_?: string;
+};
+export type GreaterThan = {
+    ge_?: number;
+};
+export type LessThan = {
+    le_?: number;
+};
+export type OperationRequest = 'and_' | 'or_';
+export type OperatorRequest = {
+    operator?: OperationRequest;
+};
+export type TagFilterRequest = OperatorRequest & All & IsNull;
+export type StateFilterRequest = OperatorRequest & {
+    type?: Any;
+} & {
+    name?: Any;
+};
+export type FlowFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    name?: Any & Like;
+    tags?: TagFilterRequest;
+};
+export type FlowRunFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any & NotAny;
+    name?: Any & Like;
+    tags?: TagFilterRequest;
+    deployment_id?: OperatorRequest & Any & IsNull;
+    work_queue_name?: OperatorRequest & Any & IsNull;
+    state?: StateFilterRequest;
+    flow_version?: Any;
+    start_time?: Before & After & IsNull;
+    expected_start_time?: Before & After;
+    next_scheduled_start_time?: Before & After;
+    parent_task_run_id?: OperatorRequest & Any & IsNull;
+};
+export type TaskRunFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    name?: Any & Like;
+    tags?: TagFilterRequest;
+    state?: StateFilterRequest;
+    start_time?: Before & After & IsNull;
+    subflow_runs?: Exists;
+};
+export type DeploymentFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    name?: Any & Like;
+    is_schedule_active?: Equals;
+    work_queue_name?: Any;
+};
+export type WorkPoolFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    name?: Any;
+    type?: Any;
+};
+export type WorkPoolQueueFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    name?: Any;
+};
+export type UnionFilterRequest<T> = {
+    flows?: FlowFilterRequest;
+    flow_runs?: FlowRunFilterRequest;
+    task_runs?: TaskRunFilterRequest;
+    deployments?: DeploymentFilterRequest;
+    work_pools?: WorkPoolFilterRequest;
+    work_pool_queues?: WorkPoolQueueFilterRequest;
+    sort?: T;
+    offset?: number;
+    limit?: number;
+};
+export type BlockTypeFilterRequest = {
+    name?: Like;
+    slug?: Any;
+};
+export type BlockSchemaFilterRequest = {
+    operator?: OperationRequest;
+    block_type_id?: Any;
+    block_capabilities?: All;
+    id?: Any;
+    version?: Any;
+};
+export type BlockDocumentFilterRequest = {
+    operator?: OperationRequest;
+    id?: Any;
+    is_anonymous?: Equals;
+    block_type_id?: Any;
+    name?: Any;
+};
+export type FlowsFilterRequest = UnionFilterRequest<FlowSortValues>;
+export type FlowRunsFilterRequest = UnionFilterRequest<FlowRunSortValues>;
+export type TaskRunsFilterRequest = UnionFilterRequest<TaskRunSortValues>;
+export type DeploymentsFilterRequest = UnionFilterRequest<DeploymentSortValues>;
+export type FlowRunsHistoryFilterRequest = FlowRunsFilterRequest & {
+    history_start: string;
+    history_end: string;
+    history_interval_seconds: number;
+};
+export type NotificationsFilterRequest = {
+    flow_run_notification_policy_filter?: {
+        is_active?: Equals;
+    };
+    offset?: number;
+    limit?: number;
+};
+export type SavedSearchesFilterRequest = {
+    offset?: number;
+    limit?: number;
+};
+export type LogsFilterRequest = {
+    logs?: {
+        operator?: OperationRequest;
+        level?: GreaterThan & LessThan;
+        timestamp?: Before & After;
+        flow_run_id?: Any;
+        task_run_id?: Any;
+    };
+    sort?: LogSortValues;
+    offset?: number;
+    limit?: number;
+};
+export type ConcurrencyLimitsFilterRequest = {
+    offset?: number;
+    limit?: number;
+};
+export type BlockTypesFilterRequest = {
+    block_types?: BlockTypeFilterRequest;
+    block_schemas?: BlockSchemaFilterRequest;
+    offset?: number;
+    limit?: number;
+};
+export type BlockSchemasFilterRequest = {
+    block_schemas?: BlockSchemaFilterRequest;
+    offset?: number;
+    limit?: number;
+};
+export type BlockDocumentsFilterRequest = {
+    block_documents?: BlockDocumentFilterRequest;
+    block_types?: BlockTypeFilterRequest;
+    block_schemas?: BlockSchemaFilterRequest;
+    include_secrets?: boolean;
+    offset?: number;
+    limit?: number;
+};
+export type WorkQueuesFilterRequest = {
+    work_queues?: {
+        operator?: OperationRequest;
+        name?: Any & StartsWith;
+    };
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolsFilterRequest = {
+    work_pools?: WorkPoolFilterRequest;
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolQueuesFilterRequest = {
+    work_pools?: WorkPoolFilterRequest;
+    offset?: number;
+    limit?: number;
+};
+export type WorkPoolWorkersFilterRequest = {
+    workers?: {
+        operator?: OperationRequest;
+        last_heartbeat_time?: Before & After;
+    };
+    limit?: number;
+    offset?: number;
+};

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

@@ -1,10 +1,7 @@
 export * from './BlockDocumentCreateRequest';
-export * from './BlockDocumentFilterRequest';
 export * from './BlockDocumentResponse';
 export * from './BlockDocumentUpdateRequest';
-export * from './BlockSchemaFilterRequest';
 export * from './BlockSchemaResponse';
-export * from './BlockTypeFilterRequest';
 export * from './BlockTypeResponse';
 export * from './ConcurrencyLimitCreateRequest';
 export * from './ConcurrencyLimitResponse';
@@ -18,9 +15,7 @@ export * from './FlowRunGraphResponse';
 export * from './FlowRunHistoryResponse';
 export * from './FlowRunResponse';
 export * from './LogResponse';
-export * from './LogsRequestFilter';
 export * from './NotificationCreateRequest';
-export * from './NotificationFilter';
 export * from './NotificationResponse';
 export * from './NotificationUpdateRequest';
 export * from './SavedSearchResponse';
@@ -42,9 +37,7 @@ export * from './WorkPoolQueueRequest';
 export * from './WorkPoolQueueResponse';
 export * from './WorkPoolRequest';
 export * from './WorkPoolResponse';
-export * from './WorkPoolWorkerFilter';
 export * from './WorkPoolWorkerResponse';
-export * from './WorkQueueFilterResponse';
 export * from './WorkQueueHealthPolicyResponse';
 export * from './WorkQueueRequest';
 export * from './WorkQueueResponse';

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

@@ -2,15 +2,11 @@ export * from './api';
 export * from './ApiRouteParams';
 export * from './BlockDocument';
 export * from './BlockDocumentCreate';
-export * from './BlockDocumentFilter';
 export * from './BlockDocumentUpdate';
 export * from './BlockSchema';
-export * from './BlockSchemaFilter';
 export * from './BlockType';
-export * from './BlockTypeFilter';
 export * from './ConcurrencyLimit';
 export * from './ConcurrencyLimitCreate';
-export * from './ConcurrencyLimitsFilter';
 export * from './CreatedOrUpdatedBy';
 export * from './CronSchedule';
 export * from './CronStringLengthError';
@@ -64,3 +60,4 @@ export * from './WorkQueueEdit';
 export * from './WorkQueueFilter';
 export * from './WorkQueueHealthPolicy';
 export * from './WorkQueueStatus';
+export * from './Filters';