@prefecthq/prefect-ui-library 1.0.0

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

@@ -0,0 +1,32 @@
+import { StateUpdate, TimelineNode } from '../models';
+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>;
+    getFlowRunsHistory: (filter: FlowRunsHistoryFilter) => Promise<RunHistory[]>;
+    getFlowRunsGraph: (flowRunId: string) => Promise<GraphNode[]>;
+    getFlowRunsTimeline: (flowRunId: string) => Promise<TimelineNode[]>;
+    retryFlowRun: (flowRunId: string) => Promise<void>;
+    setFlowRunState: (flowRunId: string, body: StateUpdate) => Promise<void>;
+    resumeFlowRun: (flowRunId: string) => Promise<void>;
+    deleteFlowRun: (flowRunId: string) => Promise<void>;
+}
+export declare class WorkspaceFlowRunsApi extends WorkspaceApi implements IWorkspaceFlowRunsApi {
+    protected routePrefix: string;
+    private readonly batcher;
+    getFlowRun(id: string): Promise<FlowRun>;
+    getFlowRuns(filter?: UnionFilters): Promise<FlowRun[]>;
+    getFlowRunsCount(filter?: UnionFilters): Promise<number>;
+    getFlowRunsHistory(filter: FlowRunsHistoryFilter): Promise<RunHistory[]>;
+    getFlowRunsGraph(flowRunId: string): Promise<GraphNode[]>;
+    getFlowRunsTimeline(id: string): Promise<TimelineNode[]>;
+    retryFlowRun(id: string): Promise<void>;
+    setFlowRunState(id: string, body: StateUpdate): Promise<void>;
+    resumeFlowRun(id: string): Promise<void>;
+    deleteFlowRun(flowRunId: string): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { Flow } from '../models';
+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>;
+    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>;
+    deleteFlow(flowId: string): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { SavedSearch, SavedSearchCreate } from '../models/SavedSearch';
+import { WorkspaceApi } from '../services/WorkspaceApi';
+export declare class WorkspaceSavedSearchesApi extends WorkspaceApi {
+    protected routePrefix: string;
+    getSavedSearches(filter?: {}): 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

@@ -0,0 +1,19 @@
+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>;
+    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>;
+    setTaskRunState(id: string, body: StateUpdate): Promise<void>;
+    deleteTaskRun(taskRunId: string): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { WorkPoolQueueCreate, WorkPoolQueue, WorkPoolQueueEdit } from '../models';
+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[]>;
+    getWorkPoolQueueByName: (workPoolName: string, queueName: string) => Promise<WorkPoolQueue>;
+    updateWorkPoolQueue: (workPoolName: string, queueName: string, request: WorkPoolQueueCreate) => Promise<void>;
+    pauseWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
+    resumeWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
+    deleteWorkPoolQueue: (workPoolName: string, queueName: string) => Promise<void>;
+}
+export declare class WorkspaceWorkPoolQueuesApi extends WorkspaceApi implements IWorkspaceWorkPoolQueuesApi {
+    protected routePrefix: string;
+    createWorkPoolQueue(workPoolName: string, request: WorkPoolQueueCreate): Promise<WorkPoolQueue>;
+    getWorkPoolQueues(workPoolName: string, filter?: PaginatedWorkPoolQueueFilter): 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>;
+    resumeWorkPoolQueue(workPoolName: string, queueName: string): Promise<void>;
+    deleteWorkPoolQueue(workPoolName: string, queueName: string): Promise<void>;
+    updateWorkPoolQueuePriority(workPoolName: string, queueName: string, priority: number): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { FlowRun, WorkQueueCreate, WorkQueueEdit, WorkQueueStatus } from '../models';
+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[]>;
+    createWorkQueue: (request: WorkQueueCreate) => Promise<WorkQueue>;
+    pauseWorkQueue: (workQueueId: string) => Promise<void>;
+    resumeWorkQueue: (workQueueId: string) => Promise<void>;
+    updateWorkQueue: (workQueueId: string, request: WorkQueueEdit) => Promise<void>;
+    deleteWorkQueue: (workQueueId: string) => Promise<void>;
+    getRuns: (workQueueId: string) => Promise<FlowRun[]>;
+    getWorkQueueStatus: (workQueueId: string) => Promise<WorkQueueStatus>;
+}
+export declare class WorkspaceWorkQueuesApi extends WorkspaceApi implements IWorkspaceWorkQueuesApi {
+    protected routePrefix: string;
+    getWorkQueue(id: string): Promise<WorkQueue>;
+    getWorkQueueByName(name: string): Promise<WorkQueue>;
+    getWorkQueues(filter: PaginatedFilter): Promise<WorkQueue[]>;
+    createWorkQueue(request: WorkQueueCreate): Promise<WorkQueue>;
+    pauseWorkQueue(id: string): Promise<void>;
+    resumeWorkQueue(id: string): Promise<void>;
+    updateWorkQueue(id: string, request: WorkQueueEdit): Promise<void>;
+    deleteWorkQueue(id: string): Promise<void>;
+    getRuns(id: string): Promise<FlowRun[]>;
+    getWorkQueueStatus(id: string): Promise<WorkQueueStatus>;
+}

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

@@ -0,0 +1,14 @@
+import { InjectionKey } from 'vue';
+import { MaybeRef } from '../types/reactivity';
+export declare const workspaceFeatureFlags: readonly [];
+export type WorkspaceFeatureFlag = typeof workspaceFeatureFlags[number];
+export declare const workspacePermissions: readonly ["create:automation", "create:block", "create:concurrency_limit", "create:deployment", "create:flow_run", "create:flow", "create:log", "create:notification_policy", "create:saved_search", "create:task_run", "create:work_queue", "create:work_pool_queue", "create:work_pool", "create:workspace_bot_access", "create:workspace_user_access", "delete:automation", "delete:block", "delete:concurrency_limit", "delete:deployment", "delete:flow_run", "delete:flow", "delete:notification_policy", "delete:saved_search", "delete:task_run", "delete:work_queue", "delete:work_pool_queue", "delete:work_pool", "delete:workspace_bot_access", "delete:workspace_user_access", "read:automation", "read:block", "read:concurrency_limit", "read:deployment", "read:flow_run", "read:flow", "read:log", "read:notification_policy", "read:saved_search", "read:task_run", "read:work_queue", "read:work_pool_queue", "read:work_pool", "read:workspace_bot_access", "read:workspace_settings", "read:workspace_user_access", "run:deployment", "update:automation", "update:block", "update:deployment", "update:flow_run", "update:flow", "update:notification_policy", "update:task_run", "update:work_queue", "update:work_pool_queue", "update:work_pool", "update:workspace_bot_access", "update:workspace_settings", "update:workspace_user_access", "update:workspace"];
+export type WorkspacePermission = typeof workspacePermissions[number];
+export type PermissionValue = boolean | undefined;
+export type PermissionVerb<T extends string> = T extends `${infer Action}:${string}` ? Action : never;
+export type Can<T extends string> = {
+    [K in PermissionVerb<T>]: Extract<T, `${K}:${string}`> extends `${string}:${infer Key}` ? Record<Key, PermissionValue> : never;
+};
+export type PermissionCheck<T> = (permission: T) => PermissionValue;
+export declare function createCan<T extends string>(permissions: MaybeRef<Readonly<T[]>>): Can<T>;
+export declare const canKey: InjectionKey<Can<WorkspacePermission | WorkspaceFeatureFlag>>;

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

@@ -0,0 +1,26 @@
+export * from './AdminApi';
+export * from './Api';
+export * from './can';
+export * from './HealthApi';
+export * from './Mapper';
+export * from './Mocker';
+export * from './RouteGuardExecutioner';
+export * from './schemas';
+export * from './SimpleIdManager';
+export * from './UiApi';
+export * from './WorkspaceApi';
+export * from './WorkspaceBlockCapabilitiesApi';
+export * from './WorkspaceBlockDocumentsApi';
+export * from './WorkspaceBlockSchemasApi';
+export * from './WorkspaceBlockTypesApi';
+export * from './WorkspaceDeploymentsApi';
+export * from './WorkspaceFlowRunsApi';
+export * from './WorkspaceFlowsApi';
+export * from './WorkspaceLogsApi';
+export * from './WorkspaceNotificationsApi';
+export * from './WorkspaceSavedSearchesApi';
+export * from './WorkspaceTaskRunsApi';
+export * from './WorkspaceWorkPoolQueuesApi';
+export * from './WorkspaceWorkPoolsApi';
+export * from './WorkspaceWorkQueuesApi';
+export * from './WorkspaceWorkPoolWorkersApi';

package/dist/types/src/services/schemas/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_SCHEMA_PROPERTY_LEVEL = 2;

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

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './properties';
+export * from './resolvers';
+export * from './utilities';

package/dist/types/src/services/schemas/properties/SchemaPropertyAny.d.ts

@@ -0,0 +1,13 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyAny extends SchemaPropertyService {
+    protected get default(): unknown;
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+    private referenceResponse;
+    private referenceRequest;
+    private getDefaultValueForFirstDefinition;
+    private isDefaultValueForReference;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyArray.d.ts

@@ -0,0 +1,9 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyArray extends SchemaPropertyService {
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected get default(): unknown;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyBlock.d.ts

@@ -0,0 +1,10 @@
+import { BlockDocumentValue } from '../../../models/api/BlockDocumentCreateRequest';
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyBlock extends SchemaPropertyService {
+    protected readonly default: BlockDocumentValue;
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyBoolean.d.ts

@@ -0,0 +1,9 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyBoolean extends SchemaPropertyService {
+    protected get default(): unknown;
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyInteger.d.ts

@@ -0,0 +1,9 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyInteger extends SchemaPropertyService {
+    protected get default(): unknown;
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyNull.d.ts

@@ -0,0 +1,8 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyNone extends SchemaPropertyService {
+    readonly component: null;
+    readonly default: undefined;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaPropertyNone): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyNumber.d.ts

@@ -0,0 +1,10 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaPropertyInputAttrs, SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyNumber extends SchemaPropertyService {
+    protected get default(): unknown;
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected get attrs(): SchemaPropertyInputAttrs;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyObject.d.ts

@@ -0,0 +1,11 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+export declare class SchemaPropertyObject extends SchemaPropertyService {
+    protected get component(): SchemaPropertyComponentWithProps;
+    protected get default(): unknown;
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+    private maxLevelRequestValue;
+    private maxLevelResponseValue;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyService.d.ts

@@ -0,0 +1,63 @@
+import { SelectOption } from '@prefecthq/prefect-design';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaProperty, SchemaPropertyInputAttrs, SchemaPropertyMeta, SchemaValue } from '../../../types/schemas';
+import { Require } from '../../../types/utilities';
+import { ComponentDefinition } from '../../../utilities/components';
+import { ValidationMethod, ValidationMethodFactory } from '../../../utilities/validation';
+export type SchemaPropertyServiceSource = {
+    property: SchemaProperty;
+    level: number;
+};
+export type SchemaPropertyServiceConstructor = new (source: SchemaPropertyServiceSource) => SchemaPropertyService;
+export declare abstract class SchemaPropertyService {
+    /**
+     * Converts a schema value from the ui into the correct value for the api
+     */
+    protected abstract request(value: SchemaValue): SchemaValue;
+    /**
+     * Converts a schema value from the api into the correct value for the ui
+     */
+    protected abstract response(value: SchemaValue): SchemaValue;
+    /**
+     * Returns the vue component and any props necessary to render the property in the schema form
+     */
+    protected abstract get component(): SchemaPropertyComponentWithProps;
+    /**
+     * Returns the value needed for the @property {PropertyComponentWithProps} property to be
+     * rendered when no value exists or the value is invalid
+     */
+    protected abstract get default(): SchemaValue;
+    /**
+     * Can be extended to add property specific validation rules. Implemented here because this is not required
+     */
+    protected get validators(): ValidationMethodFactory[];
+    /**
+     * Can be extended to add property specific attrs rules. Implemented here because this is not required
+     */
+    protected get attrs(): SchemaPropertyInputAttrs;
+    protected property: SchemaProperty;
+    protected level: number;
+    protected withProps: <T extends ComponentDefinition>(...args: Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? [component: T, props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined] : [component: T, props: Omit<InstanceType<T>["$props"], "modelValue">]) => Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? {
+        component: T;
+        props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined;
+    } : {
+        component: T;
+        props: Omit<InstanceType<T>["$props"], "modelValue">;
+    };
+    protected get isMaxLevel(): boolean;
+    constructor({ property, level }: SchemaPropertyServiceSource);
+    mapResponseValue(value: SchemaValue): SchemaValue;
+    mapRequestValue(value: SchemaValue): SchemaValue | undefined;
+    getDefaultValue(): SchemaValue;
+    getComponent(): SchemaPropertyComponentWithProps;
+    getValidators(required: boolean): ValidationMethod[];
+    getAttrs(): SchemaPropertyInputAttrs;
+    getMeta(required: boolean): SchemaPropertyMeta | null;
+    protected componentIs(component: ComponentDefinition): boolean;
+    protected invalid(): void;
+    protected has<T extends keyof SchemaProperty>(key: T): this is {
+        property: SchemaProperty & Require<SchemaProperty, T>;
+    };
+    protected getSelectOptions(): SelectOption[];
+    protected isDefaultValue(value: SchemaValue): boolean;
+}

package/dist/types/src/services/schemas/properties/SchemaPropertyString.d.ts

@@ -0,0 +1,15 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaPropertyComponentWithProps } from '../../../services/schemas/utilities';
+import { SchemaValue } from '../../../types/schemas';
+import { ValidationMethodFactory } from '../../../utilities/validation';
+export declare class SchemaPropertyString extends SchemaPropertyService {
+    protected get validators(): ValidationMethodFactory[];
+    protected request(value: SchemaValue): unknown;
+    protected response(value: SchemaValue): unknown;
+    protected get default(): SchemaValue;
+    protected get component(): SchemaPropertyComponentWithProps;
+    private requestDateValue;
+    private responseDateValue;
+    private requestDateTimeValue;
+    private responseDateTimeValue;
+}

package/dist/types/src/services/schemas/properties/factory.d.ts

@@ -0,0 +1,3 @@
+import { SchemaPropertyService } from '../../../services/schemas/properties/SchemaPropertyService';
+import { SchemaProperty } from '../../../types/schemas';
+export declare function schemaPropertyServiceFactory(property: SchemaProperty, level: number): SchemaPropertyService;

package/dist/types/src/services/schemas/properties/index.d.ts

@@ -0,0 +1,10 @@
+export * from './SchemaPropertyArray';
+export * from './SchemaPropertyBlock';
+export * from './SchemaPropertyBoolean';
+export * from './SchemaPropertyNull';
+export * from './SchemaPropertyNumber';
+export * from './SchemaPropertyObject';
+export * from './SchemaPropertyService';
+export * from './SchemaPropertyString';
+export * from './SchemaPropertyAny';
+export * from './factory';

package/dist/types/src/services/schemas/resolvers/blockReferences.d.ts

@@ -0,0 +1,3 @@
+import { BlockDocumentReferencesResponse } from '../../../models';
+import { SchemaValues } from '../../../types/schemas';
+export declare function schemaValuesBlockReferencesResolver(values: SchemaValues, references: BlockDocumentReferencesResponse | undefined): SchemaValues;

package/dist/types/src/services/schemas/resolvers/definitions.d.ts

@@ -0,0 +1,5 @@
+import { SchemaResolver } from '../../../services/schemas/resolvers/schemas';
+import { SchemaDefinitions, SchemaProperties, SchemaProperty } from '../../../types/schemas';
+export declare const schemaDefinitionsResolver: SchemaResolver;
+export declare function resolveSchemaPropertiesDefinitions(properties: SchemaProperties | undefined, definitions: SchemaDefinitions): SchemaProperties | undefined;
+export declare function resolveSchemaPropertyDefinition(property: SchemaProperty | undefined, definitions: SchemaDefinitions): SchemaProperty | undefined;

package/dist/types/src/services/schemas/resolvers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './definitions';
+export * from './meta';
+export * from './blockReferences';

package/dist/types/src/services/schemas/resolvers/meta.d.ts

@@ -0,0 +1,2 @@
+import { SchemaResolver } from '../../../services/schemas/resolvers/schemas';
+export declare const schemaMetaResolver: SchemaResolver;

package/dist/types/src/services/schemas/resolvers/schemas.d.ts

@@ -0,0 +1,4 @@
+import { ResolverCallback } from '../../../services/schemas/utilities';
+import { Schema } from '../../../types/schemas';
+export type SchemaResolver = ResolverCallback<Schema>;
+export declare const resolveSchema: SchemaResolver;

package/dist/types/src/services/schemas/utilities.d.ts

@@ -0,0 +1,28 @@
+import { SchemaProperty, SchemaPropertyInputAttrs, Schema, SchemaValues, SchemaValue, SchemaPropertyAnyOf, SchemaPropertyAllOf } from '../../types/schemas';
+import { ValidationMethod } from '../../utilities/validation';
+export type SchemaPropertyComponentWithProps = ReturnType<typeof schemaPropertyComponentWithProps> | null;
+export declare const schemaPropertyComponentWithProps: <T extends import("../../utilities/components").ComponentDefinition>(...args: Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? [component: T, props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined] : [component: T, props: Omit<InstanceType<T>["$props"], "modelValue">]) => Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? {
+    component: T;
+    props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined;
+} : {
+    component: T;
+    props: Omit<InstanceType<T>["$props"], "modelValue">;
+};
+export declare function getSchemaDefaultValues(schema: Schema): SchemaValues;
+export declare function getSchemaPropertyDefaultValue(property: SchemaProperty, level?: number): SchemaValue;
+export declare function getSchemaResponseValue(schema: Schema, values: SchemaValues): SchemaValues;
+export declare function getSchemaRequestValue(schema: Schema, values: SchemaValues): SchemaValues;
+export declare function getSchemaPropertyResponseValue(property: SchemaProperty, value: SchemaValue): SchemaValue;
+export declare function getSchemaPropertyRequestValue(property: SchemaProperty, value: SchemaValue): SchemaValue;
+export declare function getSchemaPropertyAttrs(property: SchemaProperty): SchemaPropertyInputAttrs;
+export declare function getSchemaPropertyPlaceholder(property: SchemaProperty): string | undefined;
+export declare function getSchemaPropertyComponentWithDefaultProps({ component, props }: NonNullable<SchemaPropertyComponentWithProps>): NonNullable<SchemaPropertyComponentWithProps>;
+export declare function getSchemaPropertyDefaultValidators(property: SchemaProperty, required: boolean): ValidationMethod[];
+export type ResolverCallback<T> = (schema: T) => T;
+export declare function resolve<T>(value: T, resolvers: ResolverCallback<T>[]): T;
+export declare function getSchemaValueDefinition(property: SchemaProperty, value: SchemaValue): Schema | null;
+export declare function getSchemaValueAnyOfDefinition(property: SchemaPropertyAnyOf, value: SchemaValue): Schema | null;
+export declare function getSchemaValueAnyOfDefinitionIndex({ anyOf: definitions }: SchemaPropertyAnyOf, value: SchemaValue): number | null;
+export declare function getSchemaValueAllOfDefinition(property: SchemaPropertyAllOf, value: SchemaValue): Schema | null;
+export declare function getSchemaValueAllOfDefinitionIndex({ allOf: definitions }: SchemaPropertyAllOf, value: SchemaValue): number | null;
+export declare function getSchemaValueDefinitionIndex(definitions: Schema[], value: SchemaValue): number | null;

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

@@ -0,0 +1,2 @@
+export declare const colorModes: readonly ["achromatopsia", "deuteranopia", "deuteranomaly", "protaponia", "protanomaly", "tritanomaly", "tritanopia"];
+export type ColorMode = typeof colorModes[number];

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

@@ -0,0 +1,7 @@
+import { RouteLocationNormalized, RouteLocationRaw } from 'vue-router';
+export type MaybePromise<T> = T | Promise<T>;
+export type RouteGuardReturn = MaybePromise<void | Error | RouteLocationRaw | boolean>;
+export interface RouteGuard {
+    before?: (to: RouteLocationNormalized, from: RouteLocationNormalized) => RouteGuardReturn;
+    after?: (to: RouteLocationNormalized, from: RouteLocationNormalized) => void;
+}

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

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+declare const flowSortValues: readonly ["CREATED_DESC", "UPDATED_DESC", "NAME_DESC", "NAME_ASC"];
+export type FlowSortValues = typeof flowSortValues[number];
+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 type DeploymentSortValues = typeof deploymentSortValues[number];
+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 type FlowRunSortValues = typeof flowRunSortValues[number];
+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 type TaskRunSortValues = typeof taskRunSortValues[number];
+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;
+}[];
+export {};