@prefecthq/prefect-ui-library 1.0.0

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

@@ -0,0 +1,131 @@
+import { FlowRunSortValues, FlowSortValues, TaskRunSortValues } from '../types/SortOptionTypes';
+/** A list where results will be returned only if they match all the values in the list */
+type all_ = {
+    all_?: string[];
+};
+/** A list where results will be returned if any of the values are included in the list */
+type any_ = {
+    any_?: string[];
+};
+type like_ = {
+    like_?: string;
+};
+/** A list where results will be returned if values don't match any in the list */
+type not_any_ = {
+    not_any_?: string[];
+};
+/** Matches on boolean equality */
+type eq_ = {
+    eq_?: boolean;
+};
+/** Matches on boolean equality */
+type exists_ = {
+    exists_?: boolean;
+};
+/** If true, returns results whose key is null */
+type is_null_ = {
+    is_null_?: boolean;
+};
+/** A date-time string to include results starting at or before this time */
+type before_ = {
+    before_?: string;
+};
+/** A date-time string to include results starting at or after this time */
+type after_ = {
+    after_?: string;
+};
+type operator_ = 'and_' | 'or_';
+export interface Filter {
+    id?: any_;
+    name?: any_ & like_;
+    tags?: all_ & is_null_;
+    operator?: operator_;
+}
+export interface DeploymentFilter extends Filter {
+    is_schedule_active?: eq_;
+}
+export type FlowFilter = Filter;
+export type StateFilter = {
+    type?: any_;
+    name?: any_;
+    operator?: operator_;
+};
+export type TimeFrameFilter = before_ & after_;
+export interface FlowRunFilter extends Filter {
+    id?: any_ & not_any_;
+    deployment_id?: any_ & is_null_;
+    state?: StateFilter;
+    flow_version?: any_;
+    work_queue_name?: any_;
+    /**
+     * Flow run actual starts
+     */
+    start_time?: TimeFrameFilter;
+    /**
+     * Flow run scheduled starts
+     */
+    expected_start_time?: TimeFrameFilter;
+    next_scheduled_start_time?: TimeFrameFilter;
+    parent_task_run_id?: any_ & is_null_;
+    task_runs?: TaskRunFilter;
+}
+export interface TaskRunFilter extends Filter {
+    id?: any_ & not_any_;
+    state?: StateFilter;
+    start_time?: TimeFrameFilter;
+    subflow_runs?: exists_;
+}
+export interface WorkPoolFilter extends Omit<Filter, 'tags' | 'name'> {
+    name?: any_;
+    type?: any_;
+}
+export type PaginatedWorkPoolFilter = {
+    work_pools?: WorkPoolFilter;
+    limit?: number;
+    offset?: number;
+};
+export interface WorkPoolQueueFilter extends Omit<Filter, 'tags' | 'name'> {
+    name?: any_;
+}
+export type PaginatedWorkPoolQueueFilter = {
+    work_pools?: WorkPoolQueueFilter;
+    limit?: number;
+    offset?: number;
+};
+export type PaginatedFilter = {
+    limit?: number;
+    offset?: number;
+};
+type StringKeys<T extends Filter> = Extract<keyof T, string>;
+type Sortable<T extends Filter> = PaginatedFilter & {
+    sort?: `${Uppercase<StringKeys<T>>}_${'ASC' | 'DESC'}`;
+};
+type RunSort<T extends string> = PaginatedFilter & {
+    sort?: T;
+};
+export type DeploymentsFilter = {
+    deployments?: DeploymentFilter;
+};
+export type FlowsFilter = {
+    flows?: FlowFilter;
+};
+export type TaskRunsFilter = {
+    task_runs?: TaskRunFilter;
+};
+export type FlowRunsFilter = {
+    flow_runs?: FlowRunFilter;
+};
+export type WorkPoolsFilter = {
+    work_pools?: WorkPoolFilter;
+};
+export type WorkPoolQueuesFilter = {
+    work_pool_queues?: WorkPoolQueueFilter;
+};
+export type UnionFilters = FlowsFilter & DeploymentsFilter & FlowRunsFilter & TaskRunsFilter & WorkPoolsFilter & WorkPoolQueuesFilter & (Sortable<FlowFilter & DeploymentFilter> | RunSort<FlowSortValues | FlowRunSortValues | TaskRunSortValues>);
+interface Historical {
+    history_start: string;
+    history_end: string;
+    history_interval_seconds: number;
+}
+export type FlowRunsHistoryFilter = UnionFilters & Historical;
+export {};

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

@@ -0,0 +1 @@
+export type FormAction = 'Create' | 'Save';

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

@@ -0,0 +1,2 @@
+import { Api } from '../services/Api';
+export type Constructor<T extends Api> = new (...args: any[]) => T;

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

@@ -0,0 +1,33 @@
+import { AnyCase, NumberRange } from '../types';
+export declare const CronKeywords: readonly ["@midnight", "@hourly", "@daily", "@weekly", "@monthly", "@yearly", "@annually"];
+declare const MonthValuesShort: readonly ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+declare const MonthValuesLong: readonly ["JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE", "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER"];
+export type CronMonthValuesAlt = AnyCase<typeof MonthValuesShort[number] | typeof MonthValuesLong[number]>;
+export type CronWildcard = '*';
+export type CronList = ',';
+export type CronRange = '-';
+export type CronStep = '/';
+export type CronMinuteValueMin = 0;
+export type CronMinuteValueMax = 59;
+export type CronMinuteValue = NumberRange<CronMinuteValueMin, CronMinuteValueMax>[number];
+export type CronHourValueMin = 0;
+export type CronHourValueMax = 23;
+export type CronHourValue = NumberRange<CronHourValueMin, CronHourValueMax>[number];
+export type CronDayMonthValueMin = 1;
+export type CronDayMonthValueMax = 31;
+export type CronDayMonthValue = NumberRange<CronDayMonthValueMin, CronDayMonthValueMax>[number];
+export type CronMonthValueMin = 1;
+export type CronMonthValueMax = 12;
+export type CronMonthValue = NumberRange<CronMonthValueMin, CronMonthValueMax>[number];
+export type CronDayWeekValueMin = 0;
+export type CronDayWeekValueMax = 6;
+export type CronDayWeekValue = NumberRange<CronDayWeekValueMin, CronDayWeekValueMax>[number];
+export declare const CronMinuteValues: readonly [];
+export type CronKeyword = typeof CronKeywords[number];
+export type CronRandomExpression = AnyCase<'R' | 'RANDOM'>;
+export type CronString = string | CronKeyword;
+export type CronKeywordMap = Record<CronKeyword, string>;
+export declare const cronKeywordMap: CronKeywordMap;
+export declare function isCronKeyword(cron: string | CronKeyword): cron is CronKeyword;
+export declare function containsCronRandomExpression(cron: CronString): boolean;
+export {};

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

@@ -0,0 +1 @@
+export type ClassValue = string | (string | Record<string, boolean>)[];

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

@@ -0,0 +1,3 @@
+export type DateString = string;
+export type DatePartShort = 'h' | 'd' | 'w' | 'm' | 'y';
+export declare function isDatePartShort(input: string): input is DatePartShort;

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

@@ -0,0 +1,30 @@
+import { StateType } from '../models/StateType';
+import { FlowRunSortValues } from '../types/SortOptionTypes';
+export type FlowRunFilters = {
+    name?: string;
+    sort?: FlowRunSortValues;
+    startDate?: Date;
+    endDate?: Date;
+    state?: StateType[];
+    deployment?: string[];
+    flow?: string[];
+    tag?: string[];
+    workQueue?: string[];
+    workPool?: string[];
+    workPoolName?: string[];
+    workPoolQueue?: string[];
+};
+export type FlowRunFiltersInRoute = {
+    'name'?: string;
+    'sort'?: string;
+    'start-date'?: string;
+    'end-date'?: string;
+    'state'?: string[];
+    'deployment'?: string[];
+    'flow'?: string[];
+    'tag'?: string[];
+    'work-queue'?: string[];
+    'work-pool'?: string[];
+    'work-pool-name'?: string[];
+    'work-pool-queue'?: string[];
+};

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

@@ -0,0 +1,14 @@
+export * from './buttons';
+export * from './classes';
+export * from './ColorMode';
+export * from './css';
+export * from './dates';
+export * from './reactivity';
+export * from './RouteGuard';
+export * from './SortOptionTypes';
+export * from './states';
+export * from './tabs';
+export * from './tailwind';
+export * from './UnionFilters';
+export * from './utilities';
+export * from './schemas';

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

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export type MaybeRef<T> = Ref<T> | T;

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

@@ -0,0 +1,65 @@
+import { SchemaPropertyComponentWithProps } from '../services/schemas/utilities';
+import { Require } from '../types/utilities';
+import { ValidationMethod } from '../utilities/validation';
+export type SchemaValue = unknown;
+export type SchemaValues = Record<string, SchemaValue | undefined>;
+export declare const SchemaStringFormats: readonly ["date", "regex", "date-time", "time-delta", "email", "json-string", "password"];
+export declare const SchemaTypes: readonly ["block", "null", "string", "boolean", "integer", "number", "array", "object"];
+export declare const BaseDefinitionRefString: "#/definitions/";
+export type SchemaType = typeof SchemaTypes[number];
+export type SchemaStringFormat = typeof SchemaStringFormats[number];
+export type SchemaEnum<T> = T[];
+export type SchemaReference = `${typeof BaseDefinitionRefString}${string}`;
+export type SchemaDefinitions = Record<string, Schema | undefined>;
+export type BlockSchemaReference = {
+    blockSchemaChecksum: string;
+    blockTypeSlug: string;
+};
+export type BlockSchemaReferences = Record<string, BlockSchemaReference | undefined>;
+export type SchemaPropertyAnyOf = Require<SchemaProperty, 'anyOf'>;
+export type SchemaPropertyAllOf = Require<SchemaProperty, 'allOf'>;
+export type SchemaProperties = Record<string, SchemaProperty | undefined>;
+export type SchemaPropertyInputAttrs = Record<string, unknown>;
+export type SchemaPropertyMetaOptions = {
+    attrs?: SchemaPropertyInputAttrs;
+    validators?: ValidationMethod | ValidationMethod[];
+    required?: boolean;
+};
+export type SchemaPropertyMeta = SchemaPropertyComponentWithProps & SchemaPropertyMetaOptions;
+export type SchemaProperty = {
+    blockTypeSlug?: string;
+    meta?: SchemaPropertyMeta;
+    position?: number;
+    $ref?: SchemaReference;
+    anyOf?: Schema[];
+    allOf?: Schema[];
+    example?: string;
+    alias?: string;
+    default?: unknown;
+    description?: string;
+    enum?: SchemaEnum<unknown>;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    format?: SchemaStringFormat;
+    items?: SchemaProperty;
+    maximum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    minimum?: number;
+    minItems?: number;
+    minLength?: number;
+    multipleOf?: number;
+    pattern?: string;
+    properties?: SchemaProperties;
+    required?: string[];
+    title?: string;
+    type?: SchemaType;
+    uniqueItems?: boolean;
+};
+export type Schema = SchemaProperty & {
+    blockSchemaReferences?: BlockSchemaReferences;
+    secretFields?: string[];
+    definitions?: SchemaDefinitions;
+};
+export declare function isSchemaValues(input: unknown): input is SchemaValues;
+export declare function schemaHas<T extends Schema | SchemaProperty, P extends keyof T>(schema: T, property: P): schema is T & Require<T, P>;

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

@@ -0,0 +1,3 @@
+export declare const prefectStateNames: readonly ["Scheduled", "Late", "Resuming", "Pending", "Paused", "Running", "Completed", "Cancelled", "Cancelling", "Crashed", "Failed", "TimedOut"];
+export type PrefectStateNames = typeof prefectStateNames[number];
+export declare const prefectStateNamesWithoutScheduled: readonly ["Pending", "Paused", "Running", "Completed", "Cancelled", "Cancelling", "Crashed", "Failed", "TimedOut"];

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

@@ -0,0 +1,19 @@
+export type Tab = {
+    title: string;
+    key: string;
+    icon?: string;
+    class?: string;
+};
+export type RouterTab = Tab & {
+    route: {
+        name: string;
+        hash?: string;
+    };
+};
+export declare function isRouterTab(input: Tab | RouterTab): input is RouterTab;
+type WithCount<T> = T & {
+    count: number | null;
+};
+export type ListTab = WithCount<Tab>;
+export type ListRouterTab = WithCount<RouterTab>;
+export {};

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

@@ -0,0 +1 @@
+export type TailwindColor = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | '50' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';

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

@@ -0,0 +1,7 @@
+export type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+export type Require<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type AnyCase<T extends string> = string extends T ? string : T extends `${infer F1}${infer F2}${infer R}` ? (`${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}`) : T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : '';
+export type NumberRange<N extends number, M extends number, Result extends unknown[] = [N]> = (Result['length'] extends M ? [...Result, M] : NumberRange<N, M, [...Result, Result['length']]>);
+export type MaybeArray<T> = T | T[];

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

@@ -0,0 +1,38 @@
+import { InjectionKey } from 'vue';
+import { WorkspaceApiConfig } from '../services/WorkspaceApi';
+import { WorkspaceBlockCapabilitiesApi } from '../services/WorkspaceBlockCapabilitiesApi';
+import { WorkspaceBlockDocumentsApi } from '../services/WorkspaceBlockDocumentsApi';
+import { WorkspaceBlockSchemasApi } from '../services/WorkspaceBlockSchemasApi';
+import { WorkspaceBlockTypesApi } from '../services/WorkspaceBlockTypesApi';
+import { WorkspaceConcurrencyLimitsApi } from '../services/WorkspaceConcurrencyLimitsApi';
+import { WorkspaceDeploymentsApi } from '../services/WorkspaceDeploymentsApi';
+import { WorkspaceFlowRunsApi } from '../services/WorkspaceFlowRunsApi';
+import { WorkspaceFlowsApi } from '../services/WorkspaceFlowsApi';
+import { WorkspaceLogsApi } from '../services/WorkspaceLogsApi';
+import { WorkspaceNotificationsApi } from '../services/WorkspaceNotificationsApi';
+import { WorkspaceSavedSearchesApi } from '../services/WorkspaceSavedSearchesApi';
+import { WorkspaceTaskRunsApi } from '../services/WorkspaceTaskRunsApi';
+import { WorkspaceWorkPoolQueuesApi } from '../services/WorkspaceWorkPoolQueuesApi';
+import { WorkspaceWorkPoolsApi } from '../services/WorkspaceWorkPoolsApi';
+import { WorkspaceWorkPoolWorkersApi } from '../services/WorkspaceWorkPoolWorkersApi';
+import { WorkspaceWorkQueuesApi } from '../services/WorkspaceWorkQueuesApi';
+export declare function createApi(workspaceConfig: WorkspaceApiConfig): {
+    blockCapabilities: import("@prefecthq/vue-compositions").CreateActions<WorkspaceBlockCapabilitiesApi>;
+    blockDocuments: import("@prefecthq/vue-compositions").CreateActions<WorkspaceBlockDocumentsApi>;
+    blockSchemas: import("@prefecthq/vue-compositions").CreateActions<WorkspaceBlockSchemasApi>;
+    blockTypes: import("@prefecthq/vue-compositions").CreateActions<WorkspaceBlockTypesApi>;
+    concurrencyLimits: import("@prefecthq/vue-compositions").CreateActions<WorkspaceConcurrencyLimitsApi>;
+    deployments: import("@prefecthq/vue-compositions").CreateActions<WorkspaceDeploymentsApi>;
+    flowRuns: import("@prefecthq/vue-compositions").CreateActions<WorkspaceFlowRunsApi>;
+    flows: import("@prefecthq/vue-compositions").CreateActions<WorkspaceFlowsApi>;
+    logs: import("@prefecthq/vue-compositions").CreateActions<WorkspaceLogsApi>;
+    notifications: import("@prefecthq/vue-compositions").CreateActions<WorkspaceNotificationsApi>;
+    taskRuns: import("@prefecthq/vue-compositions").CreateActions<WorkspaceTaskRunsApi>;
+    workQueues: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkQueuesApi>;
+    savedSearches: import("@prefecthq/vue-compositions").CreateActions<WorkspaceSavedSearchesApi>;
+    workPools: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkPoolsApi>;
+    workPoolQueues: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkPoolQueuesApi>;
+    workPoolWorkers: import("@prefecthq/vue-compositions").CreateActions<WorkspaceWorkPoolWorkersApi>;
+};
+export type CreateApi = ReturnType<typeof createApi>;
+export declare const workspaceApiKey: InjectionKey<CreateApi>;

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

@@ -0,0 +1,19 @@
+export declare function toMap<T extends any[], K extends keyof T[number]>(source: T, key: K): Map<T[number][K], T[number]>;
+export declare const choice: <T>(list: T[] | readonly T[]) => T;
+export declare const range: (min: number, max: number) => number[];
+export declare function unique<T extends any[]>(array: T): T;
+export declare function isNonEmptyArray<T extends any[]>(array: T | undefined): array is T;
+export declare function asArray<T>(input: T | T[] | null): T[];
+export declare function isSame(arrayA: any[], arrayB: any[]): boolean;
+export declare function lastItemInArray<T extends any[]>(array: T): T[number];
+export declare function allButLastArrayItems<T extends any[]>(array: T): T[number][];
+export declare function shuffle<T>(array: T[]): T[];
+export declare function isEmptyArray(value: unknown): value is unknown[];
+export declare function isStringArray(value: unknown): value is string[];
+export declare function isNumberArray(value: unknown): value is number[];
+export declare function asSingle<T>(value: T | T[]): T;
+export declare function repeat<T>(count: number, method: () => T): T[];
+export declare function some<T>(source: T[], min?: number, max?: number): T[];
+export declare function intersects(first: unknown[], ...rest: unknown[][]): boolean;
+export declare function groupBy<T, K extends keyof T>(source: T[], key: K): Map<T[K], T[]>;
+export declare function separate<T>(source: T[], filter: (value: T) => boolean): [found: T[], notFound: T[]];

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

@@ -0,0 +1,4 @@
+export declare function getCacheKey(label: string): string;
+export declare function isCacheKey(key: string): boolean;
+export declare function isOldCacheKey(key: string): boolean;
+export declare function clearOldCacheKeys(): void;

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

@@ -0,0 +1,4 @@
+import { ColorMode } from '../types/ColorMode';
+export declare function getColorModeClass(mode: ColorMode | null): string;
+export declare function isColorMode(value: unknown): value is ColorMode;
+export declare function applyColorModeClass(value: ColorMode | null): void;

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

@@ -0,0 +1,19 @@
+export type Component = {
+    $props: unknown;
+};
+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 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>;
+} : {
+    component: T;
+    props: Omit<P, E>;
+};
+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>;
+export declare function withPropsWithoutExcludedFactory<E extends string>(prop: E | E[]): <T extends ComponentDefinition>(...args: WithPropsArgs<T, E, InstanceType<T>["$props"]>) => WithProps<T, E, InstanceType<T>["$props"]>;
+export {};

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

@@ -0,0 +1 @@
+export declare function copyToClipboard(text: string, message?: string): void;

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

@@ -0,0 +1,14 @@
+export { daysInWeek, daysInYear, maxTime, millisecondsInMinute, millisecondsInHour, millisecondsInSecond, minTime, minutesInHour, monthsInQuarter, monthsInYear, quartersInYear, secondsInHour, secondsInMinute, secondsInDay, secondsInWeek, secondsInYear, secondsInMonth, secondsInQuarter } from 'date-fns';
+export declare const hoursInDay = 24;
+export declare function parseDate(value: string, reference?: Date): Date;
+export declare function isDate(value: unknown): value is Date;
+export declare function isInvalidDate(value: unknown): boolean;
+export declare function sortDates(itemA: Date, itemB: Date): number;
+export declare function formatDate(value: Date | string, format?: string): string;
+export declare function formatDateNumeric(value: Date): string;
+export declare function formatDateTimeNumeric(value: Date | string): string;
+export declare function parseDateTimeNumeric(value: string, reference?: Date): Date;
+export declare function formatTimeNumeric(value: Date | string): string;
+export declare function formatTimeShortNumeric(value: Date | string): string;
+export declare function parseTimeNumeric(value: string, reference?: Date): Date;
+export declare function formatDateTimeRelative(value: Date | string, comparedTo?: Date | string): string;

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

@@ -0,0 +1,5 @@
+import { Action } from '@prefecthq/vue-compositions';
+export type ItemType = 'Flow' | 'Deployment' | 'Flow run' | 'Work queue' | 'Block' | 'Notification' | 'Task run' | 'Concurrency Limit' | 'Work pool' | 'Work pool queue';
+type MaybeSingleParam<T extends Action, Params = Parameters<T>> = Params extends [unknown] ? Params[0] | Params : Params;
+export declare function deleteItem<T extends Action>(args: MaybeSingleParam<T>, endpoint: T, type: ItemType): Promise<ReturnType<T> | void>;
+export {};

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

@@ -0,0 +1,74 @@
+export type HttpStatusName = keyof typeof httpStatusCode;
+export type HttpStatus = typeof httpStatusCode[HttpStatusName];
+export type HttpStatusRange = keyof typeof httpStatusCodeRange;
+type HttpStatusResponse = {
+    is: (status: HttpStatusName) => boolean;
+    isInRange: (statusRange: HttpStatusRange) => boolean;
+};
+export declare function httpStatus(value: unknown): HttpStatusResponse;
+export declare const httpStatusCode: {
+    Continue: number;
+    SwitchingProtocols: number;
+    Processing: number;
+    OK: number;
+    Created: number;
+    Accepted: number;
+    NonAuthoritativeInformation: number;
+    NoContent: number;
+    ResetContent: number;
+    PartialContent: number;
+    MultiStatus: number;
+    MultipleChoices: number;
+    MovedPermanently: number;
+    MovedTemporarily: number;
+    SeeOther: number;
+    NotModified: number;
+    UseProxy: number;
+    TemporaryRedirect: number;
+    PermanentRedirect: number;
+    BadRequest: number;
+    Unauthorized: number;
+    PaymentRequired: number;
+    Forbidden: number;
+    NotFound: number;
+    MethodNotAllowed: number;
+    NotAcceptable: number;
+    ProxyAuthenticationRequired: number;
+    RequestTimeout: number;
+    Conflict: number;
+    Gone: number;
+    LengthRequired: number;
+    PreconditionFailed: number;
+    RequestEntityTooLarge: number;
+    RequestURITooLong: number;
+    UnsupportedMediaType: number;
+    RequestedRangeNotSatisfiable: number;
+    ExpectationFailed: number;
+    ImATeapot: number;
+    InsufficientSpaceOnResource: number;
+    MethodFailure: number;
+    MisdirectedRequest: number;
+    UnprocessableEntity: number;
+    Locked: number;
+    FailedDependency: number;
+    PreconditionRequired: number;
+    TooManyRequests: number;
+    RequestHeaderFieldsTooLarge: number;
+    UnavailableForLegalReasons: number;
+    InternalServerError: number;
+    NotImplemented: number;
+    BadGateway: number;
+    ServiceUnavailable: number;
+    GatewayTimeout: number;
+    HTTPVersionNotSupported: number;
+    InsufficientStorage: number;
+    NetworkAuthenticationRequired: number;
+};
+export declare const httpStatusCodeRange: {
+    informational: number[];
+    successful: number[];
+    redirection: number[];
+    clientError: number[];
+    serverError: number[];
+};
+export {};

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

@@ -0,0 +1,27 @@
+export * from './api';
+export * from './arrays';
+export * from './cache';
+export * from './colorMode';
+export * from './components';
+export * from './copy';
+export * from './dates';
+export * from './delete';
+export * from './httpStatus';
+export * from './inject';
+export * from './json';
+export * from './logs';
+export * from './math';
+export * from './numbers';
+export * from './object';
+export * from './parameters';
+export * from './processTypes';
+export * from './routes';
+export * from './savedFilters';
+export * from './seconds';
+export * from './state';
+export * from './strings';
+export * from './subscriptions';
+export * from './timeIntervals';
+export * from './timezone';
+export * from './validation';
+export * from './variables';

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

@@ -0,0 +1,2 @@
+import { InjectionKey } from 'vue';
+export declare function inject<T>(key: InjectionKey<T> | string): T;

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

@@ -0,0 +1,7 @@
+type JsonStringify = Parameters<typeof JSON.stringify>;
+type JsonValue = JsonStringify[0];
+type JsonReplacer = JsonStringify[1];
+export declare function stringify(value: JsonValue, replacer?: JsonReplacer): string;
+export declare function parseUnknownJson(value: unknown): unknown;
+export declare function stringifyUnknownJson(value: unknown): string | null | undefined;
+export {};

package/dist/types/src/utilities/languageDefinitions/json.d.ts

@@ -0,0 +1,3 @@
+import type { Grammar } from 'prismjs';
+declare const definition: Grammar;
+export { definition };

package/dist/types/src/utilities/languageDefinitions/python.d.ts

@@ -0,0 +1,2 @@
+declare const definition: Record<string, import("prismjs").GrammarValue>;
+export { definition };

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

@@ -0,0 +1,2 @@
+import { LogLevel } from '../models';
+export declare function logLevelLabel(level: LogLevel): string;

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

@@ -0,0 +1,6 @@
+export declare const random: () => number, floor: (x: number) => number, ceil: (x: number) => number;
+declare const uniform: (min: number, max: number) => number;
+declare const coinflip: (weight: number) => boolean;
+declare const weightedNumber: () => number;
+export declare function countDigits(value: number): number;
+export { uniform, coinflip, weightedNumber };

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

@@ -0,0 +1 @@
+export declare function isNumber(value: unknown): value is number;

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

@@ -0,0 +1,9 @@
+export declare function flip<K extends string, V extends string>(obj: Record<K, V>): Record<V, K>;
+export declare function omit<T extends Record<string, unknown>, K extends (keyof T)[]>(source: T, keys: K): Omit<T, K[number]>;
+export declare function clone<T>(source: T): T;
+export declare function hasProperty<T extends Record<string | symbol, unknown>>(needle: T, property: unknown): property is keyof T;
+export type MapEntriesCallback<K, V, R> = (key: K, value: V) => R;
+export declare function mapEntries<K extends string | number | symbol, V, R>(object: Record<K, V>, callback: MapEntriesCallback<K, V, R>): Record<K, R>;
+export declare function isEmptyObject(value: unknown): value is Record<string, never>;
+export declare function isTypeRequired<T extends Record<string | number | symbol, unknown>>(value: Partial<T>): value is Required<T>;
+export declare function hasString(obj: Record<string | number | symbol, unknown>, str: string): boolean;

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

@@ -0,0 +1,4 @@
+import { Schema, SchemaValues } from '../types/schemas';
+export declare function getSchemaValuesWithDefaults(values: SchemaValues, schema: Schema): SchemaValues;
+export declare function getSchemaValuesWithDefaultsJson(values: SchemaValues, schema: Schema): string;
+export declare function getSchemaDefaults(schema: Schema): SchemaValues;

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

@@ -0,0 +1 @@
+export declare function mapProcessTypeValueToProcessTypeLabel(processType: string | null | undefined): string;

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

@@ -0,0 +1,5 @@
+import { LocationQuery, LocationQueryRaw, Router } from 'vue-router';
+import { Route } from '../router';
+export declare function withQuery(route: Route, query: LocationQueryRaw): Route;
+export declare function withRedirect(route: Route, redirect?: string): Route;
+export declare function clearSelectedFilters(router: Router, parameters: string[]): LocationQuery;

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

@@ -0,0 +1,8 @@
+import { SavedSearch, SavedSearchFilter } from '../models/SavedSearch';
+export declare function isSameFilter(filterA: SavedSearchFilter, filterB: SavedSearchFilter): boolean;
+export declare const oneWeekFilter: SavedSearchFilter;
+export declare const noScheduleFilter: SavedSearchFilter;
+export declare const customSavedSearch: SavedSearch;
+export declare const oneWeekSavedSearch: SavedSearch;
+export declare const excludeScheduledSavedSearch: SavedSearch;
+export declare const defaultSavesSearches: SavedSearch[];

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

@@ -0,0 +1,9 @@
+export declare const intervals: {
+    readonly year: 31536000;
+    readonly day: 86400;
+    readonly hour: 3600;
+    readonly minute: 60;
+    readonly second: 1;
+};
+export declare function secondsToString(input: number, showOnes?: boolean): string;
+export declare function secondsToApproximateString(input: number, showOnes?: boolean): string;