@prefecthq/prefect-ui-library 1.0.0

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

@@ -0,0 +1,373 @@
+type Map = (...args: any) => any;
+type Maps = Record<string, Record<string, Map>>;
+type MapsMember<T extends Maps, S extends keyof T> = T[S][keyof T[S]];
+type Mappers<T extends Maps, S extends keyof T> = Extract<MapsMember<T, S>, Map>;
+type MapperSourceType<T extends Maps, S extends keyof T> = Parameters<Mappers<T, S>>[0];
+type MapperDestinationType<T extends Maps, S extends keyof T, D extends keyof T[S]> = ReturnType<T[S][D]>;
+export declare class Mapper<T extends Maps> {
+    private readonly mapperFunctions;
+    constructor(mapperFunctions: T);
+    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>, destination: D): MapperDestinationType<T, S, D>;
+    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null, destination: D): MapperDestinationType<T, S, D> | null;
+    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | undefined, destination: D): MapperDestinationType<T, S, D> | undefined;
+    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null | undefined, destination: D): MapperDestinationType<T, S, D> | null | undefined;
+    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>[], destination: D): MapperDestinationType<T, S, D>[];
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>>, destination: D): Record<string, MapperDestinationType<T, S, D>>;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null, destination: D): Record<string, MapperDestinationType<T, S, D>> | null;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | undefined;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | null | undefined;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]>, destination: D): Record<string, MapperDestinationType<T, S, D>[]>;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | undefined;
+    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null | undefined;
+    private bindMapper;
+}
+export declare const mapper: Mapper<{
+    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>;
+    };
+    BlockDocumentResponse: {
+        BlockDocument: MapFunction<import("..").BlockDocumentResponse, import("..").BlockDocument>;
+    };
+    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>;
+    };
+    ConcurrencyLimitCreate: {
+        ConcurrencyLimitCreateRequest: MapFunction<import("..").ConcurrencyLimitCreate, import("..").ConcurrencyLimitCreateRequest>;
+    };
+    ConcurrencyLimitResponse: {
+        ConcurrencyLimit: MapFunction<import("..").ConcurrencyLimitResponse, import("..").ConcurrencyLimit>;
+    };
+    CreatedOrUpdatedByResponse: {
+        CreatedOrUpdatedBy: MapFunction<import("..").CreatedOrUpdatedByResponse, import("..").CreatedOrUpdatedBy>;
+    };
+    Date: {
+        string: MapFunction<Date, string>;
+    };
+    DeploymentFlowRunCreate: {
+        DeploymentFlowRunRequest: MapFunction<import("..").DeploymentFlowRunCreate, Partial<{
+            name: string | null;
+            parameters: import("..").SchemaValues;
+            idempotency_key: string | null;
+            context: unknown;
+            empirical_policy: unknown;
+            tags: string[] | null;
+            parent_task_run_id: string | null;
+            infrastructure_document_id: string | null;
+            state: Partial<import("..").StateRequest>;
+        }>>;
+    };
+    DeploymentResponse: {
+        Deployment: MapFunction<import("..").DeploymentResponse, import("..").Deployment>;
+    };
+    DeploymentUpdate: {
+        DeploymentUpdateRequest: MapFunction<import("..").DeploymentUpdate, Partial<{
+            name: string | null;
+            description: string | null;
+            flow_id: string | null;
+            schedule: import("..").ScheduleResponse | null;
+            is_schedule_active: boolean;
+            parameters: import("..").SchemaValues | null;
+            tags: string[] | null;
+            storage_document_id: string | null;
+            infrastructure_document_id: string | null;
+            work_queue_name: string | null;
+            work_pool_name: string | null;
+        }>>;
+    };
+    EmpiricalPolicy: {
+        EmpiricalPolicyResponse: MapFunction<import("..").EmpiricalPolicy, import("..").EmpiricalPolicyResponse>;
+        EmpiricalPolicyRequest: MapFunction<import("..").EmpiricalPolicy, import("../models/api/EmpiricalPolicyRequest").EmpiricalPolicyRequest>;
+    };
+    EmpiricalPolicyResponse: {
+        EmpiricalPolicy: MapFunction<import("..").EmpiricalPolicyResponse, import("..").EmpiricalPolicy>;
+    };
+    Flow: {
+        FlowResponse: MapFunction<import("..").Flow, import("..").FlowResponse>;
+    };
+    FlowResponse: {
+        Flow: MapFunction<import("..").FlowResponse, import("..").Flow>;
+    };
+    FlowRunGraphResponse: {
+        GraphNode: MapFunction<import("..").FlowRunGraphResponse, import("..").GraphNode>;
+        TimelineNode: MapFunction<import("..").FlowRunGraphResponse, import("..").TimelineNode>;
+    };
+    FlowRunHistoryResponse: {
+        RunHistory: MapFunction<import("..").FlowRunHistoryResponse, import("..").RunHistory>;
+    };
+    FlowRunResponse: {
+        FlowRun: MapFunction<import("..").FlowRunResponse, import("..").FlowRun>;
+    };
+    GraphNode: {
+        FlowRunGraphResponse: MapFunction<import("..").GraphNode, import("..").FlowRunGraphResponse>;
+    };
+    Log: {
+        LogResponse: MapFunction<import("..").Log, import("..").LogResponse>;
+    };
+    LogResponse: {
+        Log: MapFunction<import("..").LogResponse, import("..").Log>;
+    };
+    NotificationCreate: {
+        NotificationCreateRequest: MapFunction<import("..").NotificationCreate, import("..").NotificationCreateRequest>;
+    };
+    NotificationResponse: {
+        Notification: MapFunction<import("..").NotificationResponse, import("..").Notification>;
+    };
+    NotificationUpdate: {
+        NotificationUpdateRequest: MapFunction<import("..").NotificationUpdate, import("..").NotificationUpdateRequest>;
+    };
+    number: {
+        string: MapFunction<number, string>;
+    };
+    RunHistory: {
+        FlowRunHistoryResponse: MapFunction<import("..").RunHistory, import("..").FlowRunHistoryResponse>;
+        DivergingBarChartItem: MapFunction<import("..").RunHistory, import("@prefecthq/vue-charts").DivergingBarChartItem<Record<string, number>>>;
+    };
+    SavedSearchCreate: {
+        SavedSearchCreateRequest: MapFunction<import("..").SavedSearchCreate, import("..").SavedSearchCreateRequest>;
+    };
+    SavedSearchFilter: {
+        FlowRunFilters: MapFunction<import("..").SavedSearchFilter, import("../types/filter").FlowRunFilters>;
+    };
+    SavedSearchResponse: {
+        SavedSearch: MapFunction<import("..").SavedSearchResponse, import("..").SavedSearch>;
+    };
+    Schedule: {
+        ScheduleResponse: MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
+        ScheduleRequest: MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
+    };
+    ScheduleResponse: {
+        Schedule: MapFunction<import("..").ScheduleResponse, import("..").Schedule>;
+    };
+    SchemaDefinitionsResponse: {
+        SchemaDefinitions: MapFunction<import("..").SchemaDefinitionsResponse, import("..").SchemaDefinitions>;
+    };
+    SchemaPropertiesResponse: {
+        SchemaProperties: MapFunction<import("..").SchemaPropertiesResponse, import("..").SchemaProperties>;
+    };
+    SchemaPropertyResponse: {
+        SchemaProperty: MapFunction<import("..").SchemaPropertyResponse, import("..").SchemaProperty>;
+    };
+    SchemaResponse: {
+        Schema: MapFunction<import("..").SchemaResponse, import("..").Schema>;
+    };
+    SchemaValues: {
+        SchemaValuesRequest: MapFunction<{
+            values: import("..").SchemaValues;
+            schema: import("..").Schema;
+        }, import("..").SchemaValues>;
+    };
+    SchemaValuesResponse: {
+        SchemaValues: MapFunction<{
+            values: import("..").SchemaValues;
+            schema: import("..").Schema;
+            references?: import("..").BlockDocumentReferencesResponse | undefined;
+        }, import("..").SchemaValues>;
+    };
+    ServerStateType: {
+        StateType: MapFunction<"COMPLETED" | "RUNNING" | "SCHEDULED" | "PENDING" | "FAILED" | "CANCELLED" | "CRASHED" | "PAUSED", "completed" | "running" | "scheduled" | "pending" | "failed" | "cancelled" | "crashed" | "paused">;
+    };
+    State: {
+        StateResponse: MapFunction<import("..").State, import("..").StateResponse>;
+    };
+    StateCreate: {
+        StateRequest: MapFunction<import("..").StateCreate, import("..").StateRequest>;
+    };
+    StateDetails: {
+        StateDetailsResponse: MapFunction<import("..").StateDetails, import("..").StateDetailsResponse>;
+        StateDetailsRequest: MapFunction<import("..").StateDetails, import("..").StateDetailsRequest>;
+    };
+    StateDetailsCreate: {
+        StateDetailsRequest: MapFunction<Partial<{
+            flowRunId: string | null;
+            taskRunId: string | null;
+            childFlowRunId: string | null;
+            scheduledTime: Date | null;
+            cacheKey: string | null;
+            cacheExpiration: Date | null;
+        }>, import("..").StateDetailsRequest>;
+    };
+    StateDetailsResponse: {
+        StateDetails: MapFunction<import("..").StateDetailsResponse, import("..").StateDetails>;
+    };
+    StateHistory: {
+        StateHistoryResponse: MapFunction<import("..").StateHistory, import("..").StateHistoryResponse>;
+    };
+    StateHistoryResponse: {
+        StateHistory: MapFunction<import("..").StateHistoryResponse, import("..").StateHistory>;
+    };
+    StateResponse: {
+        State: MapFunction<import("..").StateResponse, import("..").State>;
+    };
+    StateType: {
+        ServerStateType: MapFunction<"completed" | "running" | "scheduled" | "pending" | "failed" | "cancelled" | "crashed" | "paused", "COMPLETED" | "RUNNING" | "SCHEDULED" | "PENDING" | "FAILED" | "CANCELLED" | "CRASHED" | "PAUSED">;
+    };
+    StateUpdate: {
+        StateUpdateRequest: MapFunction<import("..").StateUpdate, import("..").StateUpdateRequest>;
+    };
+    string: {
+        Date: MapFunction<string, Date>;
+        number: MapFunction<string, number>;
+    };
+    TaskInput: {
+        TaskInputResponse: MapFunction<import("..").TaskInput, import("..").TaskInputResponse>;
+    };
+    TaskInputResponse: {
+        TaskInput: MapFunction<import("..").TaskInputResponse, import("..").TaskInput>;
+    };
+    TaskRun: {
+        TaskRunResponse: MapFunction<import("..").TaskRun, import("..").TaskRunResponse>;
+    };
+    TaskRunResponse: {
+        TaskRun: MapFunction<import("..").TaskRunResponse, import("..").TaskRun>;
+    };
+    UiFlowRunHistory: {
+        ScatterPlotItem: MapFunction<import("..").UiFlowRunHistory, {
+            id: string;
+            x: Date;
+            y: number;
+            itemClass?: string | undefined;
+        }>;
+    };
+    UiFlowRunHistoryResponse: {
+        UiFlowRunHistory: MapFunction<import("..").UiFlowRunHistoryResponse, import("..").UiFlowRunHistory>;
+    };
+    WorkerScheduledFlowRunResponse: {
+        WorkerScheduledFlowRun: MapFunction<import("..").WorkerScheduledFlowRunResponse, import("..").WorkerScheduledFlowRun>;
+    };
+    WorkerScheduledFlowRuns: {
+        WorkerScheduledFlowRunsRequest: MapFunction<Partial<{
+            workPoolQueueNames: string[];
+            scheduledBefore: string;
+            scheduledAfter: string;
+            limit: number;
+        }>, Partial<{
+            work_pool_queue_names: string[];
+            scheduled_before: string;
+            scheduled_after: string;
+            limit: number;
+        }>>;
+    };
+    WorkPool: {
+        WorkPoolResponse: MapFunction<import("..").WorkPool, import("..").WorkPoolResponse>;
+    };
+    WorkPoolCreate: {
+        WorkPoolCreateRequest: MapFunction<Partial<{
+            name: string;
+            description: string;
+            type: string;
+            isPaused: boolean;
+            concurrencyLimit: number;
+        }>, Partial<{
+            name: string;
+            description: string;
+            type: string;
+            is_paused: boolean;
+            concurrency_limit: number;
+        }>>;
+    };
+    WorkPoolEdit: {
+        WorkPoolEditRequest: MapFunction<Partial<{
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+        }>, Partial<{
+            description: string | null;
+            is_paused: boolean;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkPoolQueue: {
+        WorkPoolQueueResponse: MapFunction<import("..").WorkPoolQueue, import("..").WorkPoolQueueResponse>;
+    };
+    WorkPoolQueueCreate: {
+        WorkPoolQueueCreateRequest: MapFunction<Partial<{
+            name: string;
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+            priority: number;
+        }>, Partial<{
+            name: string;
+            description: string | null;
+            is_paused: boolean;
+            concurrency_limit: number | null;
+            priority: number;
+        }>>;
+    };
+    WorkPoolQueueEdit: {
+        WorkPoolQueueEditRequest: MapFunction<import("..").WorkPoolQueueEdit, import("..").WorkPoolQueueEditRequest>;
+    };
+    WorkPoolQueueResponse: {
+        WorkPoolQueue: MapFunction<import("..").WorkPoolQueueResponse, import("..").WorkPoolQueue>;
+    };
+    WorkPoolResponse: {
+        WorkPool: MapFunction<import("..").WorkPoolResponse, import("..").WorkPool>;
+    };
+    WorkPoolWorkerResponse: {
+        WorkPoolWorker: MapFunction<import("..").WorkPoolWorkerResponse, import("..").WorkPoolWorker>;
+    };
+    WorkQueue: {
+        WorkQueueResponse: MapFunction<import("..").WorkQueue, import("..").WorkQueueResponse>;
+    };
+    WorkQueueCreate: {
+        WorkQueueCreateRequest: MapFunction<import("..").WorkQueueCreate, Partial<{
+            name: string | null;
+            description: string | null;
+            is_paused: boolean | null;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkQueueEdit: {
+        WorkQueueEditRequest: MapFunction<Partial<{
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+        }>, Partial<{
+            description: string | null;
+            is_paused: boolean | null;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkQueueFilter: {
+        WorkQueueFilterResponse: MapFunction<import("..").WorkQueueFilter, import("..").WorkQueueFilterResponse>;
+    };
+    WorkQueueFilterResponse: {
+        WorkQueueFilter: MapFunction<import("..").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
+    };
+    WorkQueueHealthPolicyResponse: {
+        WorkQueueHealthPolicy: MapFunction<import("..").WorkQueueHealthPolicyResponse, import("..").WorkQueueHealthPolicy>;
+    };
+    WorkQueueResponse: {
+        WorkQueue: MapFunction<import("..").WorkQueueResponse, import("..").WorkQueue>;
+    };
+    WorkQueueStatusResponse: {
+        WorkQueueStatus: MapFunction<import("..").WorkQueueStatusResponse, import("..").WorkQueueStatus>;
+    };
+}>;
+export type MapFunction<S, D> = (this: typeof mapper, source: S) => D;
+export {};

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

@@ -0,0 +1,75 @@
+type Mock = (...args: any[]) => any;
+type MockParams<T extends Mock> = Parameters<T>;
+type MockReturns<T extends Mock> = ReturnType<T>;
+type OnlyRequired<T extends any[], U extends any[] = []> = Partial<T> extends T ? U : T extends [infer F, ...infer R] ? OnlyRequired<R, [...U, F]> : U;
+type MockParamsRequired<T extends Mock> = OnlyRequired<MockParams<T>>;
+type CreateArguments<T extends Record<string, Mock>, K extends keyof T> = MockParamsRequired<T[K]> extends never[] ? [key: K, args?: MockParams<T[K]>] : [key: K, args: MockParams<T[K]>];
+type CreateManyArguments<T extends Record<string, Mock>, K extends keyof T> = MockParamsRequired<T[K]> extends never[] ? [key: K, count: number, args?: MockParams<T[K]>] : [key: K, count: number, args: MockParams<T[K]>];
+export declare class Mocker<T extends Record<string, Mock>> {
+    private readonly mockerFunctions;
+    constructor(mockerFunctions: T);
+    create<K extends keyof T>(...[key, args]: CreateArguments<T, K>): MockReturns<T[K]>;
+    createMany<K extends keyof T>(...[key, count, args]: CreateManyArguments<T, K>): MockReturns<T[K]>[];
+}
+export declare const mocker: Mocker<{
+    any: MockFunction<any, []>;
+    blockDocument: MockFunction<import("..").BlockDocument, [(Partial<import("..").BlockDocument> | undefined)?]>;
+    blockDocumentData: MockFunction<Record<string, unknown>, [("url" | "email_addresses" | undefined)?]>;
+    blockSchema: MockFunction<import("..").BlockSchema, [(Partial<import("..").BlockSchema> | undefined)?]>;
+    blockSchemaCapabilities: MockFunction<string[], []>;
+    blockSchemaCapability: MockFunction<string, []>;
+    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", []>;
+    concurrencyLimit: MockFunction<import("..").ConcurrencyLimit, [(Partial<import("..").ConcurrencyLimit> | undefined)?]>;
+    createdOrUpdatedBy: MockFunction<import("..").CreatedOrUpdatedBy, [(Partial<import("..").CreatedOrUpdatedBy> | undefined)?]>;
+    date: MockFunction<Date, [(Date | undefined)?, (Date | undefined)?]>;
+    dateString: MockFunction<string, [(Date | undefined)?, (Date | undefined)?]>;
+    deployment: MockFunction<import("..").Deployment, [(Partial<import("..").Deployment> | undefined)?]>;
+    email: MockFunction<string, []>;
+    flow: MockFunction<import("..").Flow, [(Partial<import("..").Flow> | undefined)?]>;
+    flowResponse: MockFunction<import("..").FlowResponse, [(Partial<import("..").FlowResponse> | undefined)?]>;
+    flowRun: MockFunction<import("..").FlowRun, [(Partial<import("..").FlowRun> | undefined)?]>;
+    flowRunGraph: MockFunction<import("..").GraphNode[], [(Partial<import("../mocks/flowRunGraph").GraphOptions> | undefined)?]>;
+    flowRunHistory: MockFunction<import("..").RunHistory, [(Partial<import("..").RunHistory> | undefined)?]>;
+    flowRunStateHistory: MockFunction<import("..").StateHistory, [(Partial<import("..").StateHistory> | undefined)?]>;
+    graphNode: MockFunction<import("..").GraphNode, [(Partial<import("..").GraphNode> | undefined)?]>;
+    id: MockFunction<string, []>;
+    image: MockFunction<string, [((number | {
+        width: number;
+        height: number;
+    }) | undefined)?]>;
+    log: MockFunction<import("..").Log, [(Partial<import("..").Log> | undefined)?]>;
+    logLevel: MockFunction<0 | 10 | 20 | 30 | 40 | 50, []>;
+    notification: MockFunction<import("..").Notification, [(Partial<import("..").Notification> | undefined)?]>;
+    notificationCreate: MockFunction<import("..").NotificationCreate, [(Partial<import("..").NotificationCreate> | undefined)?]>;
+    noun: MockFunction<string, []>;
+    number: MockFunction<number, [(number | undefined)?, (number | undefined)?]>;
+    paragraph: MockFunction<string, [(number | undefined)?]>;
+    parameters: MockFunction<Record<string, unknown>, [(Record<string, unknown> | undefined)?, (import("..").Schema | undefined)?]>;
+    runName: MockFunction<string, []>;
+    schedule: MockFunction<import("..").Schedule, [({
+        type?: ("rrule" | "cron" | "interval") | undefined;
+    } | undefined)?, (Partial<import("..").Schedule> | undefined)?]>;
+    schema: MockFunction<import("..").Schema, [(import("..").Schema | undefined)?]>;
+    schemaProperties: MockFunction<import("..").SchemaProperties, [(import("..").SchemaProperties | undefined)?]>;
+    schemaProperty: MockFunction<import("..").SchemaProperty, [(import("..").SchemaProperty | undefined)?]>;
+    sentence: MockFunction<string, []>;
+    state: MockFunction<import("..").State, [(Partial<import("..").State> | undefined)?]>;
+    stateType: MockFunction<"completed" | "running" | "scheduled" | "pending" | "failed" | "cancelled" | "crashed" | "paused", []>;
+    string: MockFunction<string, [(number | undefined)?]>;
+    taskRun: MockFunction<import("..").TaskRun, [(Partial<import("..").TaskRun> | undefined)?]>;
+    uiFlowRunHistory: MockFunction<import("..").UiFlowRunHistory, [(Partial<import("..").UiFlowRunHistory> | undefined)?]>;
+    url: MockFunction<string, [(boolean | undefined)?]>;
+    worker: MockFunction<import("..").WorkPoolWorker, [(Partial<import("..").WorkPoolWorker> | undefined)?]>;
+    workPool: MockFunction<import("..").WorkPool, [(Partial<import("..").WorkPool> | undefined)?]>;
+    workPoolQueue: MockFunction<import("..").WorkPoolQueue, [(Partial<import("..").WorkPoolQueue> | undefined)?]>;
+    workQueue: MockFunction<import("..").WorkQueue, [(Partial<import("..").WorkQueue> | undefined)?]>;
+    workQueueCreate: MockFunction<import("..").WorkQueueCreate, [(Partial<import("..").WorkQueueCreate> | undefined)?]>;
+    workQueueFilter: MockFunction<import("..").WorkQueueFilter, [(Partial<import("..").WorkQueueFilter> | undefined)?]>;
+    workQueueHealthPolicy: MockFunction<import("..").WorkQueueHealthPolicy, [(Partial<import("..").WorkQueueHealthPolicy> | undefined)?]>;
+    workQueueStatus: MockFunction<import("..").WorkQueueStatus, [(Partial<import("..").WorkQueueStatus> | undefined)?]>;
+}>;
+export type MockFunction<T, Args extends any[]> = (this: typeof mocker, ...args: Args) => T;
+export {};

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

@@ -0,0 +1,10 @@
+import { RouteLocationNormalized } from 'vue-router';
+import { RouteGuard, RouteGuardReturn } from '../types/RouteGuard';
+export declare class RouteGuardExecutioner {
+    private static readonly global;
+    static before(to: RouteLocationNormalized, from: RouteLocationNormalized): Promise<Awaited<RouteGuardReturn>>;
+    static after(to: RouteLocationNormalized, from: RouteLocationNormalized): void;
+    static register(guard: RouteGuard): void;
+    private static getRouteGuards;
+    private static isRouteLocation;
+}

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

@@ -0,0 +1,4 @@
+export declare class SimpleIdManager {
+    private next;
+    get(): number;
+}

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

@@ -0,0 +1,9 @@
+import { InjectionKey } from 'vue';
+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[]>;
+}
+export declare const uiApiKey: InjectionKey<UiApi>;

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

@@ -0,0 +1,27 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+export type PrefectConfig = {
+    baseUrl: string;
+};
+export type PrefectCloudConfig = {
+    baseUrl: string;
+    accountId: string;
+    workspaceId: string;
+    token: string;
+};
+export type WorkspaceApiConfig = PrefectConfig | PrefectCloudConfig;
+export declare class WorkspaceApi {
+    private readonly workspaceConfig;
+    protected routePrefix: string;
+    constructor(workspaceConfig: WorkspaceApiConfig);
+    private get config();
+    private get baseUrl();
+    private get headers();
+    protected instance(): AxiosInstance;
+    protected get<T, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected delete<T, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected head<T, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected options<T, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    protected post<T, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    protected put<T, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    protected patch<T, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+}

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

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

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

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

@@ -0,0 +1,14 @@
+import { BlockSchema } from '../models/BlockSchema';
+import { BlockSchemaFilter } from '../models/BlockSchemaFilter';
+import { WorkspaceApi } from '../services/WorkspaceApi';
+export interface IWorkspaceBlockSchemasApi {
+    getBlockSchema: (blockSchemaId: string) => Promise<BlockSchema>;
+    getBlockSchemas: (filter: BlockSchemaFilter) => 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[]>;
+    getBlockSchemaForBlockType(blockTypeId: string): Promise<BlockSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { BlockDocument } from '../models/BlockDocument';
+import { BlockType } from '../models/BlockType';
+import { BlockTypeFilter } from '../models/BlockTypeFilter';
+import { WorkspaceApi } from '../services/WorkspaceApi';
+export interface IWorkspaceBlockTypesApi {
+    getBlockType: (blockTypeId: string) => Promise<BlockType>;
+    getBlockTypeBySlug: (blockTypeSlug: string) => Promise<BlockType>;
+    getBlockTypes: (filter: BlockTypeFilter) => 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[]>;
+    getBlockDocumentsByBlockTypeSlug(blockTypeSlug: string): Promise<BlockDocument[]>;
+}

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

@@ -0,0 +1,21 @@
+import { ConcurrencyLimit } from '../models/ConcurrencyLimit';
+import { ConcurrencyLimitCreate } from '../models/ConcurrencyLimitCreate';
+import { ConcurrencyLimitsFilter } from '../models/ConcurrencyLimitsFilter';
+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>;
+}
+export declare class WorkspaceConcurrencyLimitsApi extends WorkspaceApi {
+    protected routePrefix: string;
+    getConcurrencyLimits(filter?: ConcurrencyLimitsFilter): Promise<ConcurrencyLimit[]>;
+    getConcurrencyLimit(id: string): Promise<ConcurrencyLimit>;
+    getConcurrencyLimitByTag(tag: string): Promise<ConcurrencyLimit>;
+    createConcurrencyLimit(limit: ConcurrencyLimitCreate): Promise<ConcurrencyLimit>;
+    deleteConcurrencyLimit(id: string): Promise<void>;
+    deleteConcurrencyLimitByTag(tag: string): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { Deployment } from '../models/Deployment';
+import { DeploymentFlowRunCreate } from '../models/DeploymentFlowRunCreate';
+import { DeploymentUpdate } from '../models/DeploymentUpdate';
+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>;
+    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 {
+    protected routePrefix: string;
+    getDeployment(deploymentId: string): Promise<Deployment>;
+    getDeployments(filter?: UnionFilters): Promise<Deployment[]>;
+    getDeploymentsCount(filter?: UnionFilters): Promise<number>;
+    createDeploymentFlowRun(deploymentId: string, request: DeploymentFlowRunCreate): Promise<FlowRun>;
+    updateDeployment(deploymentId: string, request: DeploymentUpdate): Promise<void>;
+    pauseDeployment(id: string): Promise<void>;
+    resumeDeployment(id: string): Promise<void>;
+    deleteDeployment(deploymentId: string): Promise<void>;
+}