@prefecthq/prefect-ui-library 2.4.36 → 2.5.0

package/dist/types/src/schemas/compositions/useSchemaPropertyInput.d.ts

@@ -0,0 +1,343 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { SchemaProperty } from '../../schemas/types/schema';
+import { SchemaValueError } from '../../schemas/types/schemaValuesValidationResponse';
+import { SchemaValue } from '../../types';
+export declare function useSchemaPropertyInput(schemaProperty: MaybeRefOrGetter<SchemaProperty>, propertyValue: Ref<SchemaValue>, propertyErrors: MaybeRefOrGetter<SchemaValueError[]>): {
+    input: import("vue").ComputedRef<{
+        component: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                property: {
+                    type: import("vue").PropType<SchemaProperty>;
+                    required: true;
+                };
+                value: {
+                    type: import("vue").PropType<unknown>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:value": (args_0: unknown) => void;
+            }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                property: {
+                    type: import("vue").PropType<SchemaProperty>;
+                    required: true;
+                };
+                value: {
+                    type: import("vue").PropType<unknown>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+            }, {}, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                property: {
+                    type: import("vue").PropType<SchemaProperty>;
+                    required: true;
+                };
+                value: {
+                    type: import("vue").PropType<unknown>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+            }, {}, {}, {}, {}, {}>;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            property: {
+                type: import("vue").PropType<SchemaProperty>;
+                required: true;
+            };
+            value: {
+                type: import("vue").PropType<unknown>;
+                required: true;
+            };
+            errors: {
+                type: import("vue").PropType<SchemaValueError[]>;
+                required: true;
+            };
+            state: {
+                type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:value": (args_0: unknown) => void;
+        }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        props: Omit<Partial<{}> & Omit<{
+            readonly value: unknown;
+            readonly state: import("@prefecthq/prefect-design").State;
+            readonly errors: SchemaValueError[];
+            readonly property: SchemaProperty;
+            "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            property: {
+                type: import("vue").PropType<SchemaProperty>;
+                required: true;
+            };
+            value: {
+                type: import("vue").PropType<unknown>;
+                required: true;
+            };
+            errors: {
+                type: import("vue").PropType<SchemaValueError[]>;
+                required: true;
+            };
+            state: {
+                type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+        }, never>, ""> & Record<string, unknown>;
+    } | {
+        component: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJson>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => void;
+            }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJson>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+            }, {}, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJson>;
+                    required: true;
+                };
+                errors: {
+                    type: import("vue").PropType<SchemaValueError[]>;
+                    required: true;
+                };
+                state: {
+                    type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+            }, {}, {}, {}, {}, {}>;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJson>;
+                required: true;
+            };
+            errors: {
+                type: import("vue").PropType<SchemaValueError[]>;
+                required: true;
+            };
+            state: {
+                type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => void;
+        }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        props: Omit<Partial<{}> & Omit<{
+            readonly value: import("../../schemas/types/schemaValues").PrefectKindJson;
+            readonly state: import("@prefecthq/prefect-design").State;
+            readonly errors: SchemaValueError[];
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJson>;
+                required: true;
+            };
+            errors: {
+                type: import("vue").PropType<SchemaValueError[]>;
+                required: true;
+            };
+            state: {
+                type: import("vue").PropType<import("@prefecthq/prefect-design").State>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJson) => any) | undefined;
+        }, never>, ""> & Record<string, unknown>;
+    } | {
+        component: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJinja>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => void;
+            }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJinja>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+            }, {}, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJinja>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+            }, {}, {}, {}, {}, {}>;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJinja>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => void;
+        }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        props: Omit<Partial<{}> & Omit<{
+            readonly value: import("../../schemas/types/schemaValues").PrefectKindJinja;
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindJinja>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindJinja) => any) | undefined;
+        }, never>, ""> & Record<string, unknown>;
+    } | {
+        component: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+            }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => void;
+            }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+            }, {}, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                value: {
+                    type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable>;
+                    required: true;
+                };
+            }>> & {
+                "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+            }, {}, {}, {}, {}, {}>;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:value": (args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => void;
+        }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        props: Omit<Partial<{}> & Omit<{
+            readonly value: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable;
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: import("vue").PropType<import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable>;
+                required: true;
+            };
+        }>> & {
+            "onUpdate:value"?: ((args_0: import("../../schemas/types/schemaValues").PrefectKindWorkspaceVariable) => any) | undefined;
+        }, never>, ""> & Record<string, unknown>;
+    } | {
+        component: null;
+        props: {};
+    }>;
+};

package/dist/types/src/schemas/mapper.d.ts

@@ -1,4 +1,27 @@
-import { Mapper } from '../services/Mapper';
+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<{
     SchemaResponse: {
         Schema: MapFunction<import("./types/schemaResponse").SchemaResponse, import("./types/schema").Schema>;
@@ -9,5 +32,15 @@ export declare const mapper: Mapper<{
     SchemaPropertiesResponse: {
         SchemaProperties: MapFunction<import("./types/schemaResponse").SchemaPropertiesResponse, import("./types/schema").SchemaProperties>;
     };
+    Schema: {
+        SchemaResponse: MapFunction<import("./types/schema").Schema, import("./types/schemaResponse").SchemaResponse>;
+    };
+    SchemaProperty: {
+        SchemaPropertyResponse: MapFunction<import("./types/schema").SchemaProperty, import("./types/schemaResponse").SchemaPropertyResponse>;
+    };
+    SchemaProperties: {
+        SchemaPropertiesResponse: MapFunction<import("./types/schema").SchemaProperties, import("./types/schemaResponse").SchemaPropertiesResponse>;
+    };
 }>;
 export type MapFunction<S, D> = (this: typeof mapper, source: S) => D;
+export {};

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

@@ -8,4 +8,13 @@ export declare const maps: {
     SchemaPropertiesResponse: {
         SchemaProperties: import("../mapper").MapFunction<import("../types/schemaResponse").SchemaPropertiesResponse, import("../types/schema").SchemaProperties>;
     };
+    Schema: {
+        SchemaResponse: import("../mapper").MapFunction<import("../types/schema").Schema, import("../types/schemaResponse").SchemaResponse>;
+    };
+    SchemaProperty: {
+        SchemaPropertyResponse: import("../mapper").MapFunction<import("../types/schema").SchemaProperty, import("../types/schemaResponse").SchemaPropertyResponse>;
+    };
+    SchemaProperties: {
+        SchemaPropertiesResponse: import("../mapper").MapFunction<import("../types/schema").SchemaProperties, import("../types/schemaResponse").SchemaPropertiesResponse>;
+    };
 };

package/dist/types/src/schemas/maps/schema.d.ts

@@ -4,3 +4,6 @@ import { SchemaPropertiesResponse, SchemaPropertyResponse, SchemaResponse } from
 export declare const mapSchemaResponseToSchema: MapFunction<SchemaResponse, Schema>;
 export declare const mapSchemaPropertiesResponseToSchemaProperties: MapFunction<SchemaPropertiesResponse, SchemaProperties>;
 export declare const mapSchemaPropertyResponseToSchemaProperty: MapFunction<SchemaPropertyResponse, SchemaProperty>;
+export declare const mapSchemaToSchemaResponse: MapFunction<Schema, SchemaResponse>;
+export declare const mapSchemaPropertiesToSchemaPropertiesResponse: MapFunction<SchemaProperties, SchemaPropertiesResponse>;
+export declare const mapSchemaPropertyToSchemaPropertyResponse: MapFunction<SchemaProperty, SchemaPropertyResponse>;

package/dist/types/src/schemas/types/schema.d.ts

@@ -2,7 +2,7 @@ import { Simplify } from '../../types/utilities';
 export declare const schemaTypes: readonly ["null", "string", "boolean", "integer", "number", "array", "object"], isSchemaType: (value: unknown) => value is "string" | "number" | "boolean" | "object" | "null" | "integer" | "array";
 export type SchemaPropertyType = typeof schemaTypes[number];
 export declare function isSchemaPropertyType<T extends SchemaPropertyType | undefined>(value: unknown, type: T): value is T;
-export declare const schemaStringFormat: readonly ["date", "date-time", "regex", "password"], isSchemaStringFormat: (value: unknown) => value is "date" | "regex" | "date-time" | "password";
+export declare const schemaStringFormat: readonly ["date", "date-time", "password"], isSchemaStringFormat: (value: unknown) => value is "date" | "date-time" | "password";
 export type SchemaStringFormat = typeof schemaStringFormat[number];
 export type SchemaDefinition = `#/definitions/${string}`;
 export type SchemaProperties = Record<string, SchemaProperty>;

package/dist/types/src/schemas/types/schemaResponse.d.ts

@@ -13,7 +13,7 @@ export type SchemaPropertyResponse = {
     description?: string;
     enum?: unknown[];
     format?: SchemaStringFormat;
-    items?: SchemaPropertyResponse;
+    items?: SchemaPropertyResponse | SchemaPropertyResponse[];
     properties?: SchemaPropertiesResponse;
     required?: string[];
     title?: string;

package/dist/types/src/schemas/types/schemaValues.d.ts

@@ -1,16 +1,15 @@
-import { Simplify } from '../../types/utilities';
 export type SchemaValue = unknown;
 export type SchemaValues = Record<string, SchemaValue>;
-export declare const prefectKinds: readonly [null, "json", "jinja", "workspace_variable"], isPrefectKind: (value: unknown) => value is "json" | "jinja" | "workspace_variable" | null;
+export declare const prefectKinds: readonly ["none", "json", "jinja", "workspace_variable"], isPrefectKind: (value: unknown) => value is "json" | "none" | "jinja" | "workspace_variable";
 export type PrefectKind = typeof prefectKinds[number];
 type BasePrefectKindValue<TKind extends PrefectKind = PrefectKind, TRest extends Record<string, unknown> = Record<string, unknown>> = {
     __prefect_kind: TKind;
 } & TRest;
 export type PrefectKindValue = PrefectKindNull | PrefectKindJinja | PrefectKindJson | PrefectKindWorkspaceVariable;
-export declare function isPrefectKindValue<T extends PrefectKind = PrefectKind>(value: unknown, kind?: T): value is Simplify<PrefectKindValue & {
+export declare function isPrefectKindValue<T extends PrefectKind = PrefectKind>(value: unknown, kind?: T): value is PrefectKindValue & {
     __prefect_kind: T;
-}>;
-export type PrefectKindNull = BasePrefectKindValue<null, {
+};
+export type PrefectKindNull = BasePrefectKindValue<'none', {
     value: unknown;
 }>;
 export declare function isPrefectKindNull(value: unknown): value is PrefectKindNull;

package/dist/types/src/schemas/types/schemaValuesValidationResponse.d.ts

@@ -0,0 +1,15 @@
+export type SchemaValueError = string | SchemaValuePropertyError | SchemaValueIndexError;
+export type SchemaValuePropertyError = {
+    property: string;
+    errors: SchemaValueError[];
+};
+export declare function isSchemaValuePropertyError(value: SchemaValueError): value is SchemaValuePropertyError;
+export type SchemaValueIndexError = {
+    index: number;
+    errors: SchemaValueError[];
+};
+export declare function isSchemaValueIndexError(value: SchemaValueError): value is SchemaValueIndexError;
+export type SchemaValuesValidationResponse = {
+    errors: SchemaValueError[];
+    valid: boolean;
+};

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

@@ -0,0 +1,8 @@
+import { State } from '@prefecthq/prefect-design';
+import { SchemaValueError } from '../../schemas/types/schemaValuesValidationResponse';
+export declare function getSchemaPropertyErrors(propertyKeyOrIndex: string | number, errors: SchemaValueError[]): SchemaValueError[];
+export type SchemaPropertyError = {
+    state: State;
+    message: string | undefined;
+};
+export declare function getSchemaPropertyError(errors: SchemaValueError[]): SchemaPropertyError;

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

@@ -0,0 +1,8 @@
+import { Schema } from '../schemas/types/schema';
+import { SchemaValues } from '../schemas/types/schemaValues';
+import { SchemaValuesValidationResponse } from '../schemas/types/schemaValuesValidationResponse';
+import { WorkspaceApi } from '../services';
+export declare class WorkspaceSchemasWorkspaceApi extends WorkspaceApi {
+    protected routePrefix: string;
+    validate(schema: Schema, values: SchemaValues): Promise<SchemaValuesValidationResponse>;
+}

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

@@ -37,12 +37,12 @@ export declare abstract class SchemaPropertyService {
     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"> ? {
+    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"> & Record<string, unknown>) | undefined] : [component: T, props: Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>]) => Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? {
         component: T;
-        props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined;
+        props?: (Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>) | undefined;
     } : {
         component: T;
-        props: Omit<InstanceType<T>["$props"], "modelValue">;
+        props: Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>;
     };
     constructor({ property, level }: SchemaPropertyServiceSource);
     mapResponseValue(value: SchemaValue): SchemaValue;

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

@@ -1,12 +1,12 @@
 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").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"> ? {
+export declare const schemaPropertyComponentWithProps: <T extends import("../../utilities").ComponentDefinition>(...args: Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? [component: T, props?: (Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>) | undefined] : [component: T, props: Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>]) => Omit<Partial<InstanceType<T>["$props"]>, "modelValue"> extends Omit<InstanceType<T>["$props"], "modelValue"> ? {
     component: T;
-    props?: Omit<InstanceType<T>["$props"], "modelValue"> | undefined;
+    props?: (Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>) | undefined;
 } : {
     component: T;
-    props: Omit<InstanceType<T>["$props"], "modelValue">;
+    props: Omit<InstanceType<T>["$props"], "modelValue"> & Record<string, unknown>;
 };
 export declare function getSchemaDefaultValues(schema: Schema): SchemaValues;
 export declare function getSchemaPropertyDefaultValue(property: SchemaProperty, level?: number): SchemaValue;

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

@@ -16,6 +16,7 @@ import { WorkspaceFlowsApi } from '../services/WorkspaceFlowsApi';
 import { WorkspaceLogsApi } from '../services/WorkspaceLogsApi';
 import { WorkspaceNotificationsApi } from '../services/WorkspaceNotificationsApi';
 import { WorkspaceSavedSearchesApi } from '../services/WorkspaceSavedSearchesApi';
+import { WorkspaceSchemasWorkspaceApi } from '../services/WorkspaceSchemasWorkspaceApi';
 import { WorkspaceTaskRunsApi } from '../services/WorkspaceTaskRunsApi';
 import { WorkspaceVariablesApi } from '../services/WorkspaceVariablesApi';
 import { WorkspaceWorkPoolQueuesApi } from '../services/WorkspaceWorkPoolQueuesApi';
@@ -45,6 +46,7 @@ export declare function createApi(workspaceConfig: WorkspaceApiConfig): {
     workPools: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkPoolsApi>;
     workPoolWorkers: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkPoolWorkersApi>;
     workQueues: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkQueuesApi>;
+    schemas: import("@prefecthq/vue-compositions").CreateActions<WorkspaceSchemasWorkspaceApi>;
 };
 export type CreateApi = ReturnType<typeof createApi>;
 export declare const workspaceApiKey: InjectionKey<CreateApi>;

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

@@ -5,13 +5,13 @@ export type ComponentDefinition = {
     new (...args: unknown[]): Component;
 };
 type NoInfer<T> = T & {};
-type WithPropsArgs<T extends ComponentDefinition, E extends string = '', P = InstanceType<T>['$props']> = Omit<Partial<P>, E> extends Omit<P, E> ? [component: T, props?: Omit<P, E>] : [component: T, props: Omit<P, E>];
+type WithPropsArgs<T extends ComponentDefinition, E extends string = '', P = InstanceType<T>['$props']> = Omit<Partial<P>, E> extends Omit<P, E> ? [component: T, props?: Omit<P, E> & Record<string, unknown>] : [component: T, props: Omit<P, E> & Record<string, unknown>];
 type WithProps<T extends ComponentDefinition, E extends string = '', P = InstanceType<T>['$props']> = Omit<Partial<P>, E> extends Omit<P, E> ? {
     component: T;
-    props?: Omit<P, E>;
+    props?: Omit<P, E> & Record<string, unknown>;
 } : {
     component: T;
-    props: Omit<P, E>;
+    props: Omit<P, E> & Record<string, unknown>;
 };
 export declare function withProps<T extends ComponentDefinition>(...[component, props]: WithPropsArgs<T>): WithProps<NoInfer<T>>;
 export declare function withPropsWithoutExcluded<T extends ComponentDefinition, E extends string>(excluded: E | E[], ...[component, props]: WithPropsArgs<T, E>): WithProps<NoInfer<T>, E>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@prefecthq/prefect-ui-library",
-    "version": "2.4.36",
+    "version": "2.5.0",
     "private": false,
     "repository": {
         "type": "git",
@@ -43,7 +43,7 @@
         "@types/lodash.camelcase": "4.3.9",
         "@types/lodash.debounce": "4.0.9",
         "@types/lodash.merge": "4.6.9",
-        "@types/node": "^20.11.10",
+        "@types/node": "^20.11.16",
         "@types/prismjs": "^1.26.3",
         "@vitejs/plugin-vue": "5.0.3",
         "auto-changelog": "^2.4.0",
@@ -51,7 +51,7 @@
         "eslint": "8.56.0",
         "lodash.camelcase": "4.3.0",
         "lodash.debounce": "4.0.8",
-        "postcss": "8.4.33",
+        "postcss": "8.4.34",
         "tailwindcss": "3.4.1",
         "tsc-alias": "1.8.8",
         "typescript": "5.3.3",
@@ -72,7 +72,7 @@
         "@prefecthq/graphs": "2.1.9",
         "@types/lodash.isequal": "4.5.8",
         "axios": "1.6.2",
-        "cronstrue": "^2.47.0",
+        "cronstrue": "^2.48.0",
         "d3": "7.8.5",
         "date-fns": "2.30.0",
         "date-fns-tz": "1.3.7",