@prefecthq/prefect-ui-library 1.0.0

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

@@ -0,0 +1,27 @@
+export * from './useBlockDocument';
+export * from './useBlockSchema';
+export * from './useBlockType';
+export * from './useCan';
+export * from './useComponent';
+export * from './useDeployment';
+export * from './useDeploymentFilter';
+export * from './useFavicon';
+export * from './useFilter';
+export * from './useFlow';
+export * from './useFlowFilter';
+export * from './useFlowRun';
+export * from './useFlowRunFilter';
+export * from './useFlowRunFilterFromRoute';
+export * from './useForm';
+export * from './useOptionalRules';
+export * from './usePaginatedSubscription';
+export * from './useReactiveField';
+export * from './useReactiveForm';
+export * from './useScrollLinking';
+export * from './useShowModal';
+export * from './useTabs';
+export * from './useTaskRun';
+export * from './useTaskRunsCount';
+export * from './useWorkQueueStatus';
+export * from './useWorkspaceApi';
+export * from './useWorkspaceRoutes';

package/dist/types/src/compositions/useBlockDocument.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { BlockDocument } from '../models/BlockDocument';
+export declare function useBlockDocument(blockDocumentId: string | Ref<string | null | null>): ComputedRef<BlockDocument | undefined>;

package/dist/types/src/compositions/useBlockSchema.d.ts

@@ -0,0 +1,4 @@
+import { ComputedRef, Ref } from 'vue';
+import { BlockSchema } from '../models/BlockSchema';
+export declare function useBlockSchema(blockSchemaId: string | Ref<string | null | null>): ComputedRef<BlockSchema | undefined>;
+export declare function useBlockSchemaForBlockType(blockTypeId: string | Ref<string | null | null>): ComputedRef<BlockSchema | undefined>;

package/dist/types/src/compositions/useBlockType.d.ts

@@ -0,0 +1,4 @@
+import { ComputedRef, Ref } from 'vue';
+import { BlockType } from '../models/BlockType';
+export declare function useBlockType(blockTypeId: string | Ref<string | null | undefined>): ComputedRef<BlockType | undefined>;
+export declare function useBlockTypeBySlug(blockTypeSlug: string | Ref<string | null | undefined>): ComputedRef<BlockType | undefined>;

package/dist/types/src/compositions/useCan.d.ts

@@ -0,0 +1,2 @@
+import { Can, WorkspacePermission, WorkspaceFeatureFlag } from '../services/can';
+export declare function useCan(): Can<WorkspacePermission | WorkspaceFeatureFlag>;

package/dist/types/src/compositions/useComponent.d.ts

@@ -0,0 +1,14 @@
+import { InjectionKey } from 'vue';
+import * as components from '../components';
+type Components = typeof components;
+type ComponentDefinition<T> = {
+    new (...args: unknown[]): {
+        $props: T;
+    };
+};
+type ProvidedComponents = {
+    [P in keyof Components]?: ComponentDefinition<InstanceType<Components[P]>['$props']>;
+};
+export declare const componentsKey: InjectionKey<ProvidedComponents>;
+export declare function useComponent(): ProvidedComponents;
+export {};

package/dist/types/src/compositions/useDeployment.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { Deployment } from '../models/Deployment';
+export declare function useDeployment(deploymentId: string | Ref<string | null | undefined>): ComputedRef<Deployment | undefined>;

package/dist/types/src/compositions/useDeploymentFilter.d.ts

@@ -0,0 +1,15 @@
+import { ComputedRef, Ref } from 'vue';
+import { UseFilterArgs } from '../compositions/useFilter';
+import { DeploymentSortValues, MaybeRef, UnionFilters } from '../types';
+export type UseDeploymentFilterArgs = UseFilterArgs<DeploymentSortValues>;
+export declare function useDeploymentFilter(filters: MaybeRef<UseDeploymentFilterArgs>): ComputedRef<UnionFilters>;
+export type UseDeploymentFilterFromRoute = {
+    flows: Ref<string[]>;
+    name: Ref<string>;
+    tags: Ref<string[]>;
+    sort: Ref<DeploymentSortValues>;
+    filter: ComputedRef<UnionFilters>;
+    hasFilters: Ref<boolean>;
+    clearFilters: () => Promise<void>;
+};
+export declare function useDeploymentFilterFromRoute(filter?: MaybeRef<UseDeploymentFilterArgs>): UseDeploymentFilterFromRoute;

package/dist/types/src/compositions/useFavicon.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { StateType } from '../models/StateType';
+export declare function useFavicon(stateType: StateType | null | Ref<StateType | null | undefined>): void;

package/dist/types/src/compositions/useFilter.d.ts

@@ -0,0 +1,22 @@
+import { ComputedRef } from 'vue';
+import { MaybeRef, FlowSortValues, FlowRunSortValues, UnionFilters } from '../types';
+export type FilterSortValues = FlowSortValues | FlowRunSortValues;
+export type UseFilterArgs<T = FilterSortValues> = {
+    flows?: MaybeRef<string[]>;
+    flowName?: MaybeRef<string>;
+    deployments?: MaybeRef<string[]>;
+    deploymentName?: MaybeRef<string>;
+    deploymentTags?: MaybeRef<string[]>;
+    tags?: MaybeRef<string[]>;
+    states?: MaybeRef<string[]>;
+    startDate?: MaybeRef<Date>;
+    endDate?: MaybeRef<Date>;
+    sort?: MaybeRef<T>;
+    name?: MaybeRef<string>;
+    workQueues?: MaybeRef<string[]>;
+    workPools?: MaybeRef<string[]>;
+    workPoolName?: MaybeRef<string[]>;
+    workPoolQueues?: MaybeRef<string[]>;
+    workPoolQueueName?: MaybeRef<string[]>;
+};
+export declare function useFilter(filters: MaybeRef<UseFilterArgs>): ComputedRef<UnionFilters>;

package/dist/types/src/compositions/useFlow.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { Flow } from '../models/Flow';
+export declare function useFlow(flowId: string | Ref<string | null | undefined>): ComputedRef<Flow | undefined>;

package/dist/types/src/compositions/useFlowFilter.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, Ref } from 'vue';
+import { UseFilterArgs } from '../compositions/useFilter';
+import { FlowSortValues, MaybeRef, UnionFilters } from '../types';
+export type UseFlowFilterArgs = UseFilterArgs<FlowSortValues>;
+export declare function useFlowFilter(filters: MaybeRef<UseFlowFilterArgs>): ComputedRef<UnionFilters>;
+export type UseFlowFilterFromRoute = {
+    deployments: Ref<string[]>;
+    name: Ref<string>;
+    sort: Ref<FlowSortValues>;
+    filter: ComputedRef<UnionFilters>;
+    tags: Ref<string[]>;
+};
+export declare function useFlowFilterFromRoute(filter?: MaybeRef<UseFlowFilterArgs>): UseFlowFilterFromRoute;

package/dist/types/src/compositions/useFlowRun.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { FlowRun } from '../models/FlowRun';
+export declare function useFlowRun(flowRunId: string | Ref<string | null | undefined>): ComputedRef<FlowRun | undefined>;

package/dist/types/src/compositions/useFlowRunFilter.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, Ref } from 'vue';
+import { UseFilterArgs } from '../compositions/useFilter';
+import { FlowRunSortValues, MaybeRef, UnionFilters } from '../types';
+export type UseFlowRunFilterArgs = UseFilterArgs<FlowRunSortValues>;
+export declare function useFlowRunFilter(filters: MaybeRef<UseFlowRunFilterArgs>): ComputedRef<UnionFilters>;
+export type UseRecentFlowRunFilterArgs = Omit<UseFlowRunFilterArgs, 'startDate' | 'endDate'>;
+export declare function useRecentFlowRunFilter(filters: UseRecentFlowRunFilterArgs): Ref<UnionFilters>;

package/dist/types/src/compositions/useFlowRunFilterFromRoute.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+import { FlowRunFilters } from '../types/filter';
+import { FlowRunSortValues } from '../types/SortOptionTypes';
+import { UnionFilters } from '../types/UnionFilters';
+export type UseFlowRunFilterFromRoute = {
+    name: Ref<string>;
+    sort: Ref<FlowRunSortValues>;
+    startDate: Ref<Date>;
+    endDate: Ref<Date>;
+    states: Ref<string[]>;
+    deployments: Ref<string[]>;
+    flows: Ref<string[]>;
+    tags: Ref<string[]>;
+    workQueues: Ref<string[]>;
+    workPools: Ref<string[]>;
+    workPoolName: Ref<string[]>;
+    workPoolQueues: Ref<string[]>;
+    filter: Ref<UnionFilters>;
+    hasFilters: Ref<boolean>;
+    setFilters: (filters: FlowRunFilters) => Promise<void>;
+    updateFilters: (filters: FlowRunFilters) => Promise<void>;
+};
+export declare function useFlowRunFilterFromRoute(): UseFlowRunFilterFromRoute;

package/dist/types/src/compositions/useForm.d.ts

@@ -0,0 +1,2 @@
+import { useForm as useVeeForm } from 'vee-validate';
+export declare const useForm: typeof useVeeForm;

package/dist/types/src/compositions/useOptionalRules.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+type GenericValidateFunction = (value: unknown) => boolean | string | Promise<boolean | string>;
+type Rules = GenericValidateFunction | GenericValidateFunction[] | undefined;
+export declare function useOptionalRules(rules: Rules, apply: Ref<boolean>): Ref<Rules>;
+export {};

package/dist/types/src/compositions/usePaginatedSubscription.d.ts

@@ -0,0 +1,10 @@
+import { SubscribeArguments, UseSubscription } from '@prefecthq/vue-compositions';
+export type Paginated = {
+    limit?: number;
+    offset?: number;
+};
+export type PaginatedAction = (filters: Paginated) => Promise<any[]>;
+export type UsePaginatedSubscription<T extends PaginatedAction> = {
+    loadMore: () => void;
+} & Omit<UseSubscription<T>, 'promise'>;
+export declare function usePaginatedSubscription<T extends PaginatedAction>(...[action, args, options]: SubscribeArguments<T>): UsePaginatedSubscription<T>;

package/dist/types/src/compositions/useReactiveField.d.ts

@@ -0,0 +1,3 @@
+import { useField } from 'vee-validate';
+import { Ref } from 'vue';
+export declare function useReactiveField<T>(sourceRef: Ref<T>, ...[name, rules, opts]: Parameters<typeof useField<T>>): ReturnType<typeof useField>;

package/dist/types/src/compositions/useReactiveForm.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { useForm } from '../compositions/useForm';
+export declare function useReactiveForm<T extends Record<string, any>>(sourceRef: Ref<T>, ...[opts]: Parameters<typeof useForm<T>>): ReturnType<typeof useForm<T>>;

package/dist/types/src/compositions/useScrollLinking.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+type DisconnectScrollLink = () => void;
+type ScrollLinkReturnValue = {
+    disconnect: DisconnectScrollLink;
+    source: Ref<HTMLElement | undefined>;
+    target: Ref<HTMLElement | undefined>;
+};
+/**
+ * The useScrollLinking composition takes 2 optional element references (source, target)
+ * and attaches a scroll event listener to the source. When the scroll event of the
+ * source element is fired, the scroll position of the target is updated to match, producing
+ * a scroll linking effect.
+ *
+ * This composition will tear down when the calling component is unmounted but can be disconnected
+ * early using the returned disconnect method.
+ *
+ * @param source Ref<HTMLElement>
+ * @param target Ref<HTMLElement>
+ * @returns ScrollLinkReturnValue
+ */
+export declare function useScrollLinking(source?: Ref<HTMLElement>, target?: Ref<HTMLElement>): ScrollLinkReturnValue;
+export {};

package/dist/types/src/compositions/useShowModal.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+type UseShowModal = {
+    showModal: Ref<boolean>;
+    isOpen: Ref<boolean>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+export declare function useShowModal(): UseShowModal;
+export {};

package/dist/types/src/compositions/useTabs.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+export type ConditionalTab = {
+    label: string;
+    hidden?: boolean;
+};
+export declare function useTabs(tabs: ConditionalTab[] | Ref<ConditionalTab[]>): Ref<string[]>;

package/dist/types/src/compositions/useTaskRun.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { TaskRun } from '../models/TaskRun';
+export declare function useTaskRun(taskRunId: string | Ref<string | null | undefined>): ComputedRef<TaskRun | undefined>;

package/dist/types/src/compositions/useTaskRunsCount.d.ts

@@ -0,0 +1,2 @@
+import { ComputedRef, Ref } from 'vue';
+export declare function useTaskRunsCount(flowRunId: string | Ref<string | null | undefined>): ComputedRef<number | undefined>;

package/dist/types/src/compositions/useWorkQueueStatus.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef, Ref } from 'vue';
+import { WorkQueueStatus } from '../models/WorkQueueStatus';
+export declare function useWorkQueueStatus(workQueueId: string | Ref<string | null | undefined>): ComputedRef<WorkQueueStatus | undefined>;

package/dist/types/src/compositions/useWorkspaceApi.d.ts

@@ -0,0 +1,2 @@
+import { CreateApi } from '../utilities/api';
+export declare function useWorkspaceApi(): CreateApi;

package/dist/types/src/compositions/useWorkspaceRoutes.d.ts

@@ -0,0 +1,253 @@
+export declare function useWorkspaceRoutes(): {
+    flowRuns: () => {
+        readonly name: "workspace.flow-runs";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    flowRun: (flowRunId: string) => {
+        readonly name: "workspace.flow-runs.flow-run";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowRunId: string;
+        };
+    };
+    flowRunRadar: (flowRunId: string) => {
+        readonly name: "workspace.flow-runs.flow-run-radar";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowRunId: string;
+        };
+    };
+    taskRun: (taskRunId: string) => {
+        readonly name: "workspace.flow-runs.task-run";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly taskRunId: string;
+        };
+    };
+    flows: () => {
+        readonly name: "workspace.flows";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    flow: (flowId: string) => {
+        readonly name: "workspace.flows.flow";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly flowId: string;
+        };
+    };
+    deployments: () => {
+        readonly name: "workspace.deployments";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    deployment: (deploymentId: string) => {
+        readonly name: "workspace.deployments.deployment";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+    };
+    deploymentEdit: (deploymentId: string) => {
+        readonly name: "workspace.deployments.deployment-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+    };
+    deploymentFlowRunCreate: (deploymentId: string, parameters?: Record<string, unknown> | undefined) => {
+        readonly name: "workspace.deployments.deployment-flow-run-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly deploymentId: string;
+        };
+        readonly query: {
+            parameters: string;
+        } | {
+            parameters?: undefined;
+        };
+    };
+    workQueues: () => {
+        readonly name: "workspace.work-queues";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workQueue: (workQueueId: string) => {
+        readonly name: "workspace.work-queues.work-queue";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workQueueId: string;
+        };
+    };
+    workQueueCreate: () => {
+        readonly name: "workspace.work-queues.work-queue-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workQueueEdit: (workQueueId: string) => {
+        readonly name: "workspace.work-queues.work-queue-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workQueueId: string;
+        };
+    };
+    blocks: () => {
+        readonly name: "workspace.blocks";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    blocksCatalog: () => {
+        readonly name: "workspace.blocks.catalog";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    blocksCatalogView: (blockTypeSlug: string) => {
+        readonly name: "workspace.blocks.catalog-view";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockTypeSlug: string;
+        };
+    };
+    blockCreate: (blockTypeSlug: string) => {
+        readonly name: "workspace.blocks.block-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockTypeSlug: string;
+        };
+    };
+    block: (blockDocumentId: string) => {
+        readonly name: "workspace.blocks.block";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockDocumentId: string;
+        };
+    };
+    blockEdit: (blockDocumentId: string) => {
+        readonly name: "workspace.blocks.block-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly blockDocumentId: string;
+        };
+    };
+    notifications: () => {
+        readonly name: "workspace.notifications";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    notificationCreate: () => {
+        readonly name: "workspace.notifications.create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    notificationEdit: (notificationId: string) => {
+        readonly name: "workspace.notifications.notification-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly notificationId: string;
+        };
+    };
+    concurrencyLimit: (concurrencyLimitId: string) => {
+        readonly name: "workspace.concurrency-limits.concurrency-limit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly concurrencyLimitId: string;
+        };
+    };
+    concurrencyLimits: () => {
+        readonly name: "workspace.concurrency-limits";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPools: () => {
+        readonly name: "workspace.work-pools";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPool: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolCreate: () => {
+        readonly name: "workspace.work-pools.work-pool-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+        };
+    };
+    workPoolEdit: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolQueue: (workPoolName: string, workPoolQueueName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+            readonly workPoolQueueName: string;
+        };
+    };
+    workPoolQueueCreate: (workPoolName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue-create";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+        };
+    };
+    workPoolQueueEdit: (workPoolName: string, workPoolQueueName: string) => {
+        readonly name: "workspace.work-pools.work-pool.work-pool-queue-edit";
+        readonly params: {
+            readonly accountId?: string | undefined;
+            readonly workspaceId?: string | undefined;
+            readonly workPoolName: string;
+            readonly workPoolQueueName: string;
+        };
+    };
+};

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

@@ -0,0 +1,17 @@
+import '@prefecthq/vue-charts/dist/style.css';
+import '@prefecthq/radar/dist/style.css';
+import '@prefecthq/graphs/dist/style.css';
+export * from './components';
+export * from './compositions';
+export * from './localization';
+export * from './mocks';
+export * from './models';
+export * from './maps';
+export * from './router';
+export * from './services';
+export * from './types';
+export * from './utilities';
+import '@/styles/style.css';
+import { Plugin } from 'vue';
+declare const plugin: Plugin;
+export { plugin };

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

@@ -0,0 +1,93 @@
+export declare const localization: {
+    docs: {
+        gettingStarted: string;
+        flows: string;
+        flowRuns: string;
+        blocks: string;
+        workQueues: string;
+        notifications: string;
+        deployments: string;
+        concurrency: string;
+        automations: string;
+        workPools: string;
+        collections: string;
+    };
+    error: {
+        activateDeployment: string;
+        activateNotification: string;
+        activateWorkPool: string;
+        activateWorkPoolQueue: string;
+        activateWorkQueue: string;
+        cancelFlowRun: string;
+        changeFlowRunState: string;
+        changeTaskRunState: string;
+        createBlock: string;
+        createConcurrencyLimit: string;
+        createNotification: string;
+        createSavedSearch: string;
+        createSchedule: string;
+        createWorkPool: string;
+        createWorkPoolQueue: string;
+        createWorkQueue: string;
+        delete: (type: string) => string;
+        deleteSavedSearch: string;
+        pauseDeployment: string;
+        pauseFlowRun: string;
+        pauseNotification: string;
+        pauseWorkPool: string;
+        pauseWorkPoolQueue: string;
+        pauseWorkQueue: string;
+        removeSchedule: string;
+        resumeFlowRun: string;
+        retryRun: string;
+        scheduleFlowRun: string;
+        submitNotification: string;
+        updateBlock: string;
+        updateNotification: string;
+        updateSchedule: string;
+        updateWorkPool: string;
+        updateWorkPoolQueue: string;
+        updateWorkQueue: string;
+    };
+    success: {
+        activateDeployment: string;
+        activateNotification: string;
+        activateWorkPool: string;
+        activateWorkPoolQueue: string;
+        activateWorkQueue: string;
+        cancelFlowRun: string;
+        changeFlowRunState: string;
+        changeTaskRunState: string;
+        createBlock: string;
+        createConcurrencyLimit: string;
+        createNotification: string;
+        createSavedSearch: string;
+        createSchedule: string;
+        createWorkPool: string;
+        createWorkPoolQueue: string;
+        createWorkQueue: string;
+        delete: (type: string) => string;
+        deleteSavedSearch: string;
+        pauseDeployment: string;
+        pauseFlowRun: string;
+        pauseNotification: string;
+        pauseWorkPool: string;
+        pauseWorkPoolQueue: string;
+        pauseWorkQueue: string;
+        removeSchedule: string;
+        resumeFlowRun: string;
+        retryRun: string;
+        scheduleFlowRun: string;
+        updateBlock: string;
+        updateNotification: string;
+        updateSchedule: string;
+        updateWorkPool: string;
+        updateWorkPoolQueue: string;
+        updateWorkQueue: string;
+    };
+    info: {
+        deprecatedWorkQueue: string;
+        deploymentMissingWorkQueue: string;
+        taskInput: string;
+    };
+};