@prefecthq/prefect-ui-library 1.0.0

package/dist/types/src/models/BlockSchema.d.ts

@@ -0,0 +1,23 @@
+import { BlockType } from '../models/BlockType';
+import { Schema } from '../types/schemas';
+export interface IBlockSchema {
+    id: string;
+    created: Date;
+    updated: Date;
+    checksum: string;
+    fields: Schema;
+    blockTypeId: string;
+    blockType: BlockType;
+    capabilities: string[];
+}
+export declare class BlockSchema implements IBlockSchema {
+    readonly id: string;
+    readonly created: Date;
+    readonly updated: Date;
+    checksum: string;
+    fields: Schema;
+    blockTypeId: string;
+    blockType: BlockType;
+    capabilities: string[];
+    constructor(blockSchema: IBlockSchema);
+}

package/dist/types/src/models/BlockSchemaFilter.d.ts

@@ -0,0 +1,9 @@
+export type BlockSchemaFilter = {
+    offset?: number;
+    limit?: number;
+    blockSchemas?: {
+        blockTypeId?: {
+            any_?: string[];
+        };
+    };
+};

package/dist/types/src/models/BlockType.d.ts

@@ -0,0 +1,23 @@
+export interface IBlockType {
+    id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    documentationUrl: string | null;
+    description: string | null;
+    codeExample: string | null;
+}
+export declare class BlockType implements IBlockType {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    documentationUrl: string | null;
+    description: string | null;
+    codeExample: string | null;
+    constructor(blockType: IBlockType);
+}

package/dist/types/src/models/BlockTypeFilter.d.ts

@@ -0,0 +1,9 @@
+export type BlockTypeFilter = {
+    blockSchemas?: {
+        blockCapabilities?: {
+            all_?: string[];
+        };
+    };
+    limit?: number;
+    offset?: number;
+};

package/dist/types/src/models/ConcurrencyLimit.d.ts

@@ -0,0 +1,8 @@
+export type ConcurrencyLimit = {
+    tag: string;
+    concurrencyLimit: number;
+    id: string;
+    created?: Date;
+    updated?: Date;
+    activeSlots?: string[];
+};

package/dist/types/src/models/ConcurrencyLimitCreate.d.ts

@@ -0,0 +1,4 @@
+export type ConcurrencyLimitCreate = {
+    tag: string;
+    concurrencyLimit: number;
+};

package/dist/types/src/models/ConcurrencyLimitsFilter.d.ts

@@ -0,0 +1,4 @@
+export type ConcurrencyLimitsFilter = {
+    offset?: number;
+    limit?: number;
+};

package/dist/types/src/models/CreatedOrUpdatedBy.d.ts

@@ -0,0 +1,6 @@
+export type CreatedOrUpdatedByType = 'USER' | 'BOT' | 'DEPLOYMENT';
+export type CreatedOrUpdatedBy = {
+    id: string;
+    displayValue: string;
+    type: CreatedOrUpdatedByType;
+};

package/dist/types/src/models/CronSchedule.d.ts

@@ -0,0 +1,18 @@
+import { CronScheduleResponse, ISchedule } from '../models';
+import { CronKeyword } from '../types/cron';
+export interface ICronSchedule extends ISchedule {
+    timezone: string | null;
+    cron: string;
+    dayOr: boolean;
+}
+export declare class CronSchedule implements ICronSchedule {
+    timezone: string | null;
+    cron: string | CronKeyword;
+    dayOr: boolean;
+    constructor(schedule: Pick<ICronSchedule, 'cron' | 'timezone' | 'dayOr'>);
+    get raw(): string | CronKeyword;
+    toString({ verbose }?: {
+        verbose?: boolean;
+    }): string;
+    toResponse(): CronScheduleResponse;
+}

package/dist/types/src/models/CronStringLengthError.d.ts

@@ -0,0 +1,3 @@
+export declare class CronStringLengthError extends Error {
+    constructor(len: number);
+}

package/dist/types/src/models/Deployment.d.ts

@@ -0,0 +1,57 @@
+import { SchemaResponse } from '../models/api/SchemaResponse';
+import { CreatedOrUpdatedBy } from '../models/CreatedOrUpdatedBy';
+import { Schedule } from '../models/Schedule';
+import { Schema, SchemaValues } from '../types/schemas';
+export interface IDeployment {
+    id: string;
+    created: Date;
+    createdBy: CreatedOrUpdatedBy | null;
+    updated: Date;
+    updatedBy: CreatedOrUpdatedBy | null;
+    name: string;
+    version: string;
+    description: string | null;
+    flowId: string;
+    schedule: Schedule | null;
+    isScheduleActive: boolean;
+    parameters: SchemaValues;
+    parameterOpenApiSchema: Schema;
+    tags: string[] | null;
+    manifestPath: string | null;
+    path: string | null;
+    rawSchema: SchemaResponse | null;
+    entrypoint: string | null;
+    storageDocumentId: string | null;
+    infrastructureDocumentId: string | null;
+    infrastructureOverrides: Record<string, unknown> | null;
+    workQueueName: string | null;
+    workPoolName: string | null;
+}
+export declare class Deployment implements IDeployment {
+    readonly id: string;
+    created: Date;
+    createdBy: CreatedOrUpdatedBy | null;
+    updated: Date;
+    updatedBy: CreatedOrUpdatedBy | null;
+    name: string;
+    version: string;
+    description: string | null;
+    readonly flowId: string;
+    schedule: Schedule | null;
+    isScheduleActive: boolean;
+    parameters: SchemaValues;
+    parameterOpenApiSchema: Schema;
+    readonly rawSchema: SchemaResponse | null;
+    tags: string[] | null;
+    manifestPath: string | null;
+    path: string | null;
+    entrypoint: string | null;
+    storageDocumentId: string | null;
+    infrastructureDocumentId: string | null;
+    infrastructureOverrides: Record<string, unknown> | null;
+    workQueueName: string | null;
+    workPoolName: string | null;
+    constructor(deployment: IDeployment);
+    get deprecated(): boolean;
+    get appliedBy(): string | null;
+}

package/dist/types/src/models/DeploymentFlowRunCreate.d.ts

@@ -0,0 +1,23 @@
+import { EmpiricalPolicy } from '../models/EmpiricalPolicy';
+import { StateCreate } from '../models/StateCreate';
+import { Schema, SchemaValues } from '../types/schemas';
+type Base = {
+    name?: string | null;
+    idempotencyKey?: string | null;
+    context?: unknown;
+    empiricalPolicy?: EmpiricalPolicy;
+    tags?: string[] | null;
+    parentTaskRunId?: string | null;
+    infrastructureDocumentId?: string | null;
+    state?: StateCreate;
+};
+type WithoutParameters = Base & {
+    schema?: never;
+    parameters?: never;
+};
+type WithParameters = Base & {
+    schema: Schema;
+    parameters: SchemaValues;
+};
+export type DeploymentFlowRunCreate = WithoutParameters | WithParameters;
+export {};

package/dist/types/src/models/DeploymentUpdate.d.ts

@@ -0,0 +1,20 @@
+import { Schedule } from '../models/Schedule';
+import { Schema, SchemaValues } from '../types/schemas';
+type Base = {
+    description?: string | null;
+    schedule?: Schedule | null;
+    isScheduleActive?: boolean;
+    tags?: string[] | null;
+    workQueueName?: string | null;
+    workPoolName?: string | null;
+};
+type WithoutParameters = Base & {
+    schema?: never;
+    parameters?: never;
+};
+type WithParameters = Base & {
+    schema: Schema;
+    parameters: SchemaValues;
+};
+export type DeploymentUpdate = WithoutParameters | WithParameters;
+export {};

package/dist/types/src/models/EmpiricalPolicy.d.ts

@@ -0,0 +1,13 @@
+export interface IEmpiricalPolicy {
+    retries: number | null;
+    retryDelay: number | null;
+    maxRetries: number | null;
+    retryDelaySeconds: number | null;
+}
+export declare class EmpiricalPolicy implements IEmpiricalPolicy {
+    retries: number | null;
+    retryDelay: number | null;
+    maxRetries: number | null;
+    retryDelaySeconds: number | null;
+    constructor(empiricalPolicy: IEmpiricalPolicy);
+}

package/dist/types/src/models/ExistingHandleError.d.ts

@@ -0,0 +1,6 @@
+import { AxiosError } from 'axios';
+import { Require } from '../types/utilities';
+export type ExistingHandleError = {
+    detail: string;
+};
+export declare function isExistingHandleError(error: unknown): error is Require<AxiosError<ExistingHandleError>, 'response'>;

package/dist/types/src/models/FilterDateError.d.ts

@@ -0,0 +1,3 @@
+export declare class FilterDateError extends Error {
+    constructor();
+}

package/dist/types/src/models/FilterPrefixError.d.ts

@@ -0,0 +1,3 @@
+export declare class FilterPrefixError extends Error {
+    constructor();
+}

package/dist/types/src/models/FilterRelativeDateUnitError.d.ts

@@ -0,0 +1,3 @@
+export declare class FilterRelativeDateUnitError extends Error {
+    constructor();
+}

package/dist/types/src/models/Flow.d.ts

@@ -0,0 +1,15 @@
+export type IFlow = {
+    id: string;
+    created: Date;
+    description: string;
+    updated: Date;
+    name: string;
+};
+export declare class Flow implements IFlow {
+    readonly id: string;
+    readonly created: Date;
+    readonly updated: Date;
+    name: string;
+    description: string;
+    constructor(flow: IFlow);
+}

package/dist/types/src/models/FlowRun.d.ts

@@ -0,0 +1,77 @@
+import { CreatedOrUpdatedBy } from '../models/CreatedOrUpdatedBy';
+import { State } from '../models/State';
+import { StateType } from '../models/StateType';
+import { PrefectStateNames } from '../types';
+import { SchemaValues } from '../types/schemas';
+export interface IFlowRun {
+    id: string;
+    flowId: string;
+    deploymentId: string | null;
+    flowVersion: string | null;
+    idempotencyKey: string | null;
+    expectedStartTime: Date | null;
+    nextScheduledStartTime: string | null;
+    parameters: SchemaValues;
+    autoScheduled: boolean | null;
+    context: unknown;
+    empiricalConfig: unknown;
+    empiricalPolicy: unknown;
+    estimatedRunTime: number;
+    estimatedStartTimeDelta: number | null;
+    totalRunTime: number;
+    startTime: Date | null;
+    endTime: Date | null;
+    name: string | null;
+    parentTaskRunId: string | null;
+    stateId: string | null;
+    stateName: PrefectStateNames | null;
+    stateType: StateType | null;
+    state: State | null;
+    tags: string[] | null;
+    runCount: number | null;
+    created: Date;
+    createdBy: CreatedOrUpdatedBy | null;
+    updated: Date;
+    workQueueName: string | null;
+    workPoolName: string | null;
+    workPoolQueueName: string | null;
+}
+export declare class FlowRun implements IFlowRun {
+    readonly id: string;
+    readonly flowId: string;
+    readonly deploymentId: string | null;
+    readonly workQueueName: string | null;
+    flowVersion: string | null;
+    idempotencyKey: string | null;
+    expectedStartTime: Date | null;
+    nextScheduledStartTime: string | null;
+    parameters: SchemaValues;
+    autoScheduled: boolean | null;
+    context: unknown;
+    empiricalConfig: unknown;
+    empiricalPolicy: unknown;
+    estimatedRunTime: number;
+    estimatedStartTimeDelta: number | null;
+    totalRunTime: number;
+    startTime: Date | null;
+    endTime: Date | null;
+    name: string | null;
+    parentTaskRunId: string | null;
+    stateId: string | null;
+    stateName: PrefectStateNames | null;
+    stateType: StateType | null;
+    state: State | null;
+    tags: string[] | null;
+    runCount: number | null;
+    created: Date;
+    createdBy: CreatedOrUpdatedBy | null;
+    updated: Date;
+    workPoolName: string | null;
+    workPoolQueueName: string | null;
+    constructor(flowRun: IFlowRun);
+    get duration(): number;
+    isScheduled(): this is FlowRun & {
+        expectedStartTime: Date;
+    };
+    get delta(): string | null;
+}

package/dist/types/src/models/FlowRunHistoryMap.d.ts

@@ -0,0 +1,8 @@
+import { RunHistory } from '../models/RunHistory';
+import { StateHistory } from '../models/StateHistory';
+export declare class FlowRunHistoryMap {
+    private readonly map;
+    constructor(runHistory: RunHistory[]);
+    get(date: Date): StateHistory[];
+    private getKey;
+}

package/dist/types/src/models/GraphNode.d.ts

@@ -0,0 +1,29 @@
+import { State } from '../models/State';
+export type TaskRunInputType = 'constant' | 'parameter' | 'task_run';
+export interface IGraphNode {
+    id: string;
+    upstreamDependencies: {
+        inputType: TaskRunInputType;
+        id: string;
+    }[];
+    state: State | null;
+    expectedStartTime: Date | null;
+    estimatedRunTime: number | null;
+    totalRunTime: number | null;
+    startTime: Date | null;
+    endTime: Date | null;
+}
+export declare class GraphNode implements IGraphNode {
+    readonly id: string;
+    upstreamDependencies: {
+        inputType: TaskRunInputType;
+        id: string;
+    }[];
+    state: State | null;
+    expectedStartTime: Date | null;
+    estimatedRunTime: number | null;
+    totalRunTime: number | null;
+    startTime: Date | null;
+    endTime: Date | null;
+    constructor(graphNode: GraphNode);
+}

package/dist/types/src/models/ISchedule.d.ts

@@ -0,0 +1,7 @@
+import { ScheduleResponse } from '../models';
+export type ISchedule = {
+    raw: string | number | null | undefined;
+    timezone: string | null;
+    toString: () => string;
+    toResponse: () => ScheduleResponse;
+};

package/dist/types/src/models/IntervalSchedule.d.ts

@@ -0,0 +1,27 @@
+import { ISchedule } from '../models';
+import { IntervalScheduleResponse } from '../models/api/ScheduleResponse';
+export type Intervals = {
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+};
+export interface IIntervalSchedule extends ISchedule {
+    interval: number;
+    timezone: string | null;
+    anchorDate: Date | null;
+    getIntervals?: () => Intervals;
+}
+export declare class IntervalSchedule implements IIntervalSchedule {
+    timezone: string | null;
+    interval: number;
+    anchorDate: Date | null;
+    constructor(schedule: Pick<IIntervalSchedule, 'interval' | 'timezone' | 'anchorDate'>);
+    get raw(): number;
+    getIntervals(): Intervals;
+    toString({ verbose, neat }?: {
+        neat?: boolean;
+        verbose?: boolean;
+    }): string;
+    toResponse(): IntervalScheduleResponse;
+}

package/dist/types/src/models/InvalidSchemaValueError.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidSchemaValueError extends Error {
+    constructor();
+}

package/dist/types/src/models/Log.d.ts

@@ -0,0 +1,25 @@
+export declare const logLevel: readonly [0, 10, 20, 30, 40, 50];
+export type LogLevel = typeof logLevel[number];
+export interface ILog {
+    id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    flowRunId: string;
+    taskRunId: string | null;
+}
+export declare class Log implements ILog {
+    readonly id: string;
+    readonly created: Date;
+    readonly updated: Date;
+    name: string;
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    flowRunId: string;
+    taskRunId: string | null;
+    constructor(log: ILog);
+}

package/dist/types/src/models/NoSchemaPropertyDefaultValueError.d.ts

@@ -0,0 +1,3 @@
+export declare class NoSchemaPropertyDefaultValueError extends Error {
+    constructor();
+}

package/dist/types/src/models/Notification.d.ts

@@ -0,0 +1,21 @@
+export declare const notificationStatus: readonly ["all", "active", "paused"];
+export type NotificationStatus = typeof notificationStatus[number];
+export interface INotification {
+    id: string;
+    created: Date;
+    updated: Date;
+    isActive: boolean;
+    stateNames: string[];
+    tags: string[];
+    blockDocumentId: string;
+}
+export declare class Notification implements INotification {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    isActive: boolean;
+    stateNames: string[];
+    tags: string[];
+    blockDocumentId: string;
+    constructor(notification: INotification);
+}

package/dist/types/src/models/NotificationCreate.d.ts

@@ -0,0 +1,6 @@
+export type NotificationCreate = {
+    isActive?: boolean;
+    stateNames?: string[];
+    tags?: string[];
+    blockDocumentId: string;
+};

package/dist/types/src/models/NotificationUpdate.d.ts

@@ -0,0 +1,6 @@
+export type NotificationUpdate = {
+    isActive?: boolean;
+    stateNames?: string[];
+    tags?: string[];
+    blockDocumentId?: string;
+};

package/dist/types/src/models/PublicCron.d.ts

@@ -0,0 +1,15 @@
+import { default as Cron } from 'cronstrue';
+import { Options as CronstrueOptions } from 'cronstrue/dist/options';
+export declare class PublicCron extends Cron {
+    getFullDescription(): string;
+    getSecondsDescription(): string;
+    getMinutesDescription(): string;
+    getHoursDescription(): string;
+    getTimeOfDayDescription(): string;
+    getDayOfMonthDescription(): string | null;
+    getMonthDescription(): string;
+    getDayOfWeekDescription(): string;
+    getYearDescription(): string;
+    transformVerbosity(description: string, useVerboseFormat: boolean): string;
+    constructor(expression: string, options: CronstrueOptions);
+}

package/dist/types/src/models/RRuleSchedule.d.ts

@@ -0,0 +1,15 @@
+import { ISchedule } from '../models';
+import { RRuleScheduleResponse } from '../models/api/ScheduleResponse';
+export interface IRRuleSchedule extends ISchedule {
+    timezone: string | null;
+    rrule: string;
+}
+export declare class RRuleSchedule implements IRRuleSchedule {
+    timezone: string | null;
+    rrule: string;
+    constructor(schedule: Pick<IRRuleSchedule, 'rrule' | 'timezone'>);
+    get raw(): string;
+    getRRule(): string;
+    toString(): string;
+    toResponse(): RRuleScheduleResponse;
+}

package/dist/types/src/models/RunHistory.d.ts

@@ -0,0 +1,12 @@
+import { IStateHistory, StateHistory } from '../models/StateHistory';
+export type IRunHistory = {
+    intervalStart: Date;
+    intervalEnd: Date;
+    states: IStateHistory[];
+};
+export declare class RunHistory implements IRunHistory {
+    readonly intervalStart: Date;
+    readonly intervalEnd: Date;
+    readonly states: StateHistory[];
+    constructor(run: IRunHistory);
+}

package/dist/types/src/models/SavedSearch.d.ts

@@ -0,0 +1,24 @@
+export interface ISavedSearch {
+    id: string | null;
+    name: string;
+    filters: SavedSearchFilter;
+}
+export interface SavedSearchCreate {
+    name: string;
+    filters: SavedSearchFilter;
+}
+export declare class SavedSearch implements ISavedSearch {
+    readonly id: string | null;
+    name: string;
+    filters: SavedSearchFilter;
+    constructor(savedSearch: ISavedSearch);
+}
+export type SavedSearchFilter = {
+    state?: string[];
+    flow?: string[];
+    tag?: string[];
+    deployment?: string[];
+    workQueue?: string[];
+    startDate?: string;
+    endDate?: string;
+};

package/dist/types/src/models/Schedule.d.ts

@@ -0,0 +1,9 @@
+import { RRuleSchedule, CronSchedule, IntervalSchedule } from '../models';
+export type Schedule = RRuleSchedule | CronSchedule | IntervalSchedule;
+export declare function isSchedule(schedule: unknown): schedule is Schedule;
+export declare function isRRuleSchedule(schedule: unknown): schedule is RRuleSchedule;
+export declare function isCronSchedule(schedule: unknown): schedule is CronSchedule;
+export declare function isIntervalSchedule(schedule: unknown): schedule is IntervalSchedule;
+export declare const ScheduleTypes: readonly ["rrule", "cron", "interval"];
+export type ScheduleType = typeof ScheduleTypes[number];
+export declare function getScheduleType(schedule?: unknown): ScheduleType | null;

package/dist/types/src/models/ServerSettings.d.ts

@@ -0,0 +1,42 @@
+import { LogLevel } from '../models/Log';
+export type ServerSettings = {
+    PREFECT_HOME: string;
+    PREFECT_DEBUG_MODE: boolean;
+    PREFECT_TEST_MODE: boolean;
+    PREFECT_TEST_SETTING: string;
+    PREFECT_API_URL: string;
+    PREFECT_API_KEY: string;
+    PREFECT_CLOUD_URL: string;
+    PREFECT_API_REQUEST_TIMEOUT: number;
+    PREFECT_PROFILES_PATH: string;
+    PREFECT_LOGGING_LEVEL: LogLevel;
+    PREFECT_LOGGING_SERVER_LEVEL: LogLevel;
+    PREFECT_LOGGING_SETTINGS_PATH: string;
+    PREFECT_LOGGING_EXTRA_LOGGERS: string;
+    PREFECT_LOGGING_SERVER_ENABLED: boolean;
+    PREFECT_LOGGING_SERVER_BATCH_INTERVAL: number;
+    PREFECT_LOGGING_SERVER_BATCH_SIZE: number;
+    PREFECT_LOGGING_SERVER_MAX_LOG_SIZE: number;
+    PREFECT_AGENT_QUERY_INTERVAL: number;
+    PREFECT_AGENT_PREFETCH_SECONDS: number;
+    PREFECT_SERVER_DATABASE_CONNECTION_URL: string;
+    PREFECT_SERVER_DATABASE_ECHO: boolean;
+    PREFECT_SERVER_DATABASE_MIGRATE_ON_START: boolean;
+    PREFECT_SERVER_DATABASE_TIMEOUT: number;
+    PREFECT_SERVER_DATABASE_CONNECTION_TIMEOUT: number;
+    PREFECT_SERVER_SERVICES_SCHEDULER_LOOP_SECONDS: number;
+    PREFECT_SERVER_SERVICES_SCHEDULER_DEPLOYMENT_BATCH_SIZE: number;
+    PREFECT_SERVER_SERVICES_SCHEDULER_MAX_RUNS: number;
+    PREFECT_SERVER_SERVICES_SCHEDULER_MAX_SCHEDULED_TIME: number;
+    PREFECT_SERVER_SERVICES_SCHEDULER_INSERT_BATCH_SIZE: number;
+    PREFECT_SERVER_SERVICES_LATE_RUNS_LOOP_SECONDS: number;
+    PREFECT_SERVER_SERVICES_LATE_RUNS_AFTER_SECONDS: number;
+    PREFECT_SERVER_API_DEFAULT_LIMIT: number;
+    PREFECT_SERVER_API_HOST: number;
+    PREFECT_SERVER_API_PORT: number;
+    PREFECT_SERVER_UI_ENABLED: boolean;
+    PREFECT_SERVER_UI_API_URL: string;
+    PREFECT_SERVER_ANALYTICS_ENABLED: boolean;
+    PREFECT_SERVER_SERVICES_SCHEDULER_ENABLED: boolean;
+    PREFECT_SERVER_SERVICES_LATE_RUNS_ENABLED: boolean;
+};

package/dist/types/src/models/State.d.ts

@@ -0,0 +1,11 @@
+import { StateDetails } from '../models/StateDetails';
+import { StateType } from '../models/StateType';
+export type State = {
+    id: string;
+    type: StateType;
+    message: string;
+    stateDetails: StateDetails | null;
+    data: Record<string, unknown>;
+    timestamp: string;
+    name: string;
+};

package/dist/types/src/models/StateCreate.d.ts

@@ -0,0 +1,9 @@
+import { StateType, StateDetailsCreate } from '../models';
+export type StateCreate = {
+    type: StateType;
+    message?: string;
+    stateDetails?: StateDetailsCreate;
+    data?: Record<string, unknown>;
+    timestamp?: string;
+    name?: string;
+};