@prefecthq/prefect-ui-library 1.0.0

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

@@ -0,0 +1,10 @@
+export type StateDetails = {
+    flowRunId?: string | null;
+    taskRunId?: string | null;
+    childFlowRunId?: string | null;
+    scheduledTime?: Date | null;
+    cacheKey?: string | null;
+    cacheExpiration?: Date | null;
+    pauseTimeout?: Date | null;
+    pauseRescheduledTime?: boolean | null;
+};

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

@@ -0,0 +1,8 @@
+export type StateDetailsCreate = Partial<{
+    flowRunId: string | null;
+    taskRunId: string | null;
+    childFlowRunId: string | null;
+    scheduledTime: Date | null;
+    cacheKey: string | null;
+    cacheExpiration: Date | null;
+}>;

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

@@ -0,0 +1,16 @@
+import { StateType } from '../models/StateType';
+export type IStateHistory = {
+    stateType: StateType;
+    stateName: string;
+    countRuns: number;
+    sumEstimatedRunTime: number;
+    sumEstimatedLateness: number;
+};
+export declare class StateHistory implements IStateHistory {
+    readonly stateType: StateType;
+    readonly stateName: string;
+    readonly countRuns: number;
+    readonly sumEstimatedRunTime: number;
+    readonly sumEstimatedLateness: number;
+    constructor(state: IStateHistory);
+}

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

@@ -0,0 +1,13 @@
+export declare const stateType: readonly ["completed", "running", "scheduled", "pending", "failed", "cancelled", "crashed", "paused"];
+export type StateType = typeof stateType[number];
+export type ServerStateType = Uppercase<StateType>;
+export declare function isStateType(value: unknown): value is StateType;
+export declare const terminalStateType: string[];
+export type TerminalStateType = typeof terminalStateType[number];
+export type ServerTerminalStateType = Uppercase<TerminalStateType>;
+export declare function isTerminalStateType(value: string): value is TerminalStateType;
+export declare const stuckStateTypes: string[];
+export type StuckStateType = typeof stuckStateTypes[number];
+export declare function isStuckStateType(value: string): value is StuckStateType;
+export declare function isPausedStateType(value: string): boolean;
+export declare function isRunningStateType(value: string): boolean;

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

@@ -0,0 +1,11 @@
+import { StateDetails } from '../models/StateDetails';
+import { StateType } from '../models/StateType';
+export interface StateUpdateDetails {
+    type: StateType;
+    name?: string;
+    message?: string;
+    stateDetails?: StateDetails;
+}
+export type StateUpdate = {
+    state: StateUpdateDetails;
+};

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

@@ -0,0 +1,29 @@
+export type ITaskInput = IConstantTaskInput | IParameterTaskInput | ITaskRunTaskInput;
+export type TaskInput = ConstantTaskInput | ParameterTaskInput | TaskRunTaskInput;
+export type IConstantTaskInput = {
+    inputType: 'constant';
+    type: string;
+};
+export type IParameterTaskInput = {
+    inputType: 'parameter';
+    name: string;
+};
+export type ITaskRunTaskInput = {
+    inputType: 'task_run';
+    id: string;
+};
+export declare class ConstantTaskInput implements IConstantTaskInput {
+    readonly inputType: 'constant';
+    type: string;
+    constructor(taskInput: IConstantTaskInput);
+}
+export declare class ParameterTaskInput implements IParameterTaskInput {
+    readonly inputType: 'parameter';
+    name: string;
+    constructor(taskInput: IParameterTaskInput);
+}
+export declare class TaskRunTaskInput implements ITaskRunTaskInput {
+    readonly inputType: 'task_run';
+    id: string;
+    constructor(taskInput: ITaskRunTaskInput);
+}

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

@@ -0,0 +1,58 @@
+import { IEmpiricalPolicy } from '../models/EmpiricalPolicy';
+import { State } from '../models/State';
+import { StateType } from '../models/StateType';
+import { TaskInput } from '../models/TaskInput';
+export interface ITaskRun {
+    id: string;
+    flowRunId: string;
+    cacheExpiration: string | null;
+    cacheKey: string | null;
+    created: Date;
+    dynamicKey: string;
+    empiricalPolicy: IEmpiricalPolicy | null;
+    estimatedRunTime: number | null;
+    estimatedStartTimeDelta: number | null;
+    totalRunTime: number | null;
+    expectedStartTime: Date | null;
+    nextScheduledStartTime: string | null;
+    runCount: number | null;
+    name: string | null;
+    taskInputs: Record<string, TaskInput[]> | null;
+    taskKey: string;
+    taskVersion: string | null;
+    updated: Date;
+    startTime: Date | null;
+    endTime: Date | null;
+    stateId: string | null;
+    stateType: StateType | null;
+    state: State | null;
+    tags: string[] | null;
+}
+export declare class TaskRun implements ITaskRun {
+    readonly id: string;
+    readonly flowRunId: string;
+    cacheExpiration: string | null;
+    cacheKey: string | null;
+    created: Date;
+    dynamicKey: string;
+    empiricalPolicy: IEmpiricalPolicy | null;
+    estimatedRunTime: number | null;
+    estimatedStartTimeDelta: number | null;
+    totalRunTime: number | null;
+    expectedStartTime: Date | null;
+    nextScheduledStartTime: string | null;
+    runCount: number | null;
+    name: string | null;
+    taskInputs: Record<string, TaskInput[]> | null;
+    taskKey: string;
+    taskVersion: string | null;
+    updated: Date;
+    startTime: Date | null;
+    endTime: Date | null;
+    stateId: string | null;
+    stateType: StateType | null;
+    state: State | null;
+    tags: string[] | null;
+    constructor(taskRun: ITaskRun);
+    get duration(): number;
+}

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

@@ -0,0 +1,15 @@
+import { TimelineNodeData } from '@prefecthq/graphs';
+interface ModifiedTimelineNodeData extends Omit<TimelineNodeData, 'start'> {
+    start: Date | null;
+}
+export declare function isValidTimelineNodeData(value: TimelineNode): value is TimelineNodeData;
+export declare class TimelineNode implements ModifiedTimelineNodeData {
+    readonly id: string;
+    label: string;
+    start: Date | null;
+    end: Date | null;
+    state: string;
+    upstreamDependencies?: string[];
+    constructor(timelineNode: TimelineNode);
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { StateType } from '../models/StateType';
+export type UiFlowRunHistory = {
+    id: string;
+    stateType: StateType;
+    duration: number;
+    lateness: number;
+    timestamp: Date;
+};

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

@@ -0,0 +1,26 @@
+export declare const workPoolTypes: readonly ["ECS", "Kubernetes", "GCP Cloud Run", "Azure Container", "Docker Container", "Process"];
+export type WorkPoolType = typeof workPoolTypes[number];
+export interface IWorkPool {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    description: string | null;
+    type: string;
+    isPaused: boolean;
+    defaultQueueId: string;
+    concurrencyLimit: number | null;
+}
+export declare class WorkPool implements IWorkPool {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    description: string | null;
+    type: string;
+    isPaused: boolean;
+    defaultQueueId: string;
+    concurrencyLimit: number | null;
+    constructor(workPool: IWorkPool);
+    get typeLabel(): string;
+}

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

@@ -0,0 +1,7 @@
+export type WorkPoolCreate = Partial<{
+    name: string;
+    description: string;
+    type: string;
+    isPaused: boolean;
+    concurrencyLimit: number;
+}>;

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

@@ -0,0 +1,5 @@
+export type WorkPoolEdit = Partial<{
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+}>;

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

@@ -0,0 +1,23 @@
+export interface IWorkPoolQueue {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    workPoolId: string;
+    name: string;
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+    priority: number;
+}
+export declare class WorkPoolQueue implements IWorkPoolQueue {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    workPoolId: string;
+    name: string;
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+    priority: number;
+    constructor(workPoolQueue: IWorkPoolQueue);
+}

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

@@ -0,0 +1,7 @@
+export type WorkPoolQueueCreate = Partial<{
+    name: string;
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+    priority: number;
+}>;

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

@@ -0,0 +1,7 @@
+export type WorkPoolQueueEdit = {
+    name?: string;
+    description?: string | null;
+    isPaused?: boolean;
+    concurrencyLimit?: number | null;
+    priority?: number;
+};

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

@@ -0,0 +1,17 @@
+export interface IWorkPoolWorker {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    workPoolId: string;
+    lastHeartbeatTime: Date;
+}
+export declare class WorkPoolWorker implements IWorkPoolWorker {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    workPoolId: string;
+    lastHeartbeatTime: Date;
+    constructor(workPoolWorker: IWorkPoolWorker);
+}

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

@@ -0,0 +1,27 @@
+import { IWorkQueueFilter } from '../models/WorkQueueFilter';
+export interface IWorkQueue {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    filter?: IWorkQueueFilter;
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+    priority: number;
+    workPoolId: string;
+}
+export declare class WorkQueue implements IWorkQueue {
+    readonly id: string;
+    created: Date;
+    updated: Date;
+    name: string;
+    filter?: IWorkQueueFilter;
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+    priority: number;
+    workPoolId: string;
+    get deprecated(): boolean;
+    constructor(workQueue: IWorkQueue);
+}

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

@@ -0,0 +1,6 @@
+export type WorkQueueCreate = {
+    name: string;
+    description?: string | null;
+    isPaused?: boolean;
+    concurrencyLimit?: number | null;
+};

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

@@ -0,0 +1,5 @@
+export type WorkQueueEdit = Partial<{
+    description: string | null;
+    isPaused: boolean;
+    concurrencyLimit: number | null;
+}>;

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

@@ -0,0 +1,9 @@
+export interface IWorkQueueFilter {
+    tags: string[];
+    deploymentIds: string[];
+}
+export declare class WorkQueueFilter implements IWorkQueueFilter {
+    tags: string[];
+    deploymentIds: string[];
+    constructor(filter: IWorkQueueFilter);
+}

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

@@ -0,0 +1,4 @@
+export type WorkQueueHealthPolicy = {
+    maximumLateRuns: number;
+    maximumSecondsSinceLastPolled: number;
+};

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

@@ -0,0 +1,14 @@
+import { WorkQueueHealthPolicy } from '../models/WorkQueueHealthPolicy';
+export interface IWorkQueueStatus {
+    healthy: boolean;
+    lateRunsCount: number;
+    lastPolled: Date | null;
+    healthCheckPolicy: WorkQueueHealthPolicy;
+}
+export declare class WorkQueueStatus implements IWorkQueueStatus {
+    healthy: boolean;
+    lateRunsCount: number;
+    lastPolled: Date | null;
+    healthCheckPolicy: WorkQueueHealthPolicy;
+    constructor(workQueueStatus: IWorkQueueStatus);
+}

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

@@ -0,0 +1,6 @@
+import { FlowRun } from '../models';
+export type WorkerScheduledFlowRun = {
+    workPoolId: string;
+    workPoolQueueId: string;
+    flowRun: FlowRun;
+};

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

@@ -0,0 +1,6 @@
+export type WorkerScheduledFlowRuns = Partial<{
+    workPoolQueueNames: string[];
+    scheduledBefore: string;
+    scheduledAfter: string;
+    limit: number;
+}>;

package/dist/types/src/models/api/BlockDocumentCreateRequest.d.ts

@@ -0,0 +1,23 @@
+import { SchemaValue } from '../../types/schemas';
+export type BlockDocumentReferenceValue = {
+    $ref: {
+        block_document_id: string;
+    };
+};
+export declare function isBlockDocumentReferenceValue(value: SchemaValue): value is BlockDocumentReferenceValue;
+export type BlockDocumentValue = {
+    blockTypeSlug: string;
+    blockDocumentId: string | null;
+};
+export declare function isBlockDocumentValue(value: SchemaValue): value is BlockDocumentValue;
+export type BlockDocumentRequestData = Record<string, unknown | BlockDocumentReferenceValue>;
+export type BlockDocumentCreateNamedRequest = {
+    name: string;
+    data: BlockDocumentRequestData;
+    block_schema_id: string;
+    block_type_id: string;
+};
+export type BlockDocumentCreateAnonymousRequest = Omit<BlockDocumentCreateNamedRequest, 'name'> & {
+    is_anonymous: boolean;
+};
+export type BlockDocumentCreateRequest = BlockDocumentCreateNamedRequest | BlockDocumentCreateAnonymousRequest;

package/dist/types/src/models/api/BlockDocumentFilterRequest.d.ts

@@ -0,0 +1,12 @@
+export type BlockDocumentFilterRequest = {
+    offset?: number;
+    limit?: number;
+    block_types?: {
+        name?: {
+            like_?: string;
+        };
+        slug?: {
+            any_?: string[];
+        };
+    };
+};

package/dist/types/src/models/api/BlockDocumentResponse.d.ts

@@ -0,0 +1,25 @@
+import { BlockSchemaResponse } from '../../models/api/BlockSchemaResponse';
+import { BlockTypeResponse } from '../../models/api/BlockTypeResponse';
+export type BlockDocumentResponseData = Record<string, unknown>;
+export type BlockDocumentReferenceResponse = {
+    block_document: {
+        block_type: BlockTypeResponse;
+        id: string;
+        is_anonymous: boolean;
+        name: string;
+    };
+};
+export type BlockDocumentReferencesResponse = Record<string, BlockDocumentReferenceResponse | undefined>;
+export type BlockDocumentResponse = {
+    id: string;
+    created: string;
+    updated: string;
+    name: string;
+    data: BlockDocumentResponseData;
+    block_schema_id: string;
+    block_schema: BlockSchemaResponse;
+    block_type_id: string;
+    block_type: BlockTypeResponse;
+    block_document_references: BlockDocumentReferencesResponse;
+    is_anonymous: boolean;
+};

package/dist/types/src/models/api/BlockDocumentUpdateRequest.d.ts

@@ -0,0 +1,4 @@
+export type BlockDocumentUpdateRequest = {
+    data?: Record<string, unknown>;
+    merge_existing_data?: boolean;
+};

package/dist/types/src/models/api/BlockSchemaFilterRequest.d.ts

@@ -0,0 +1,9 @@
+export type BlockSchemaFilterRequest = {
+    offset?: number;
+    limit?: number;
+    block_schemas?: {
+        block_type_id?: {
+            any_?: string[];
+        };
+    };
+};

package/dist/types/src/models/api/BlockSchemaResponse.d.ts

@@ -0,0 +1,12 @@
+import { BlockTypeResponse } from '../../models/api/BlockTypeResponse';
+import { SchemaResponse } from '../../models/api/SchemaResponse';
+export type BlockSchemaResponse = {
+    id: string;
+    created: string;
+    updated: string;
+    checksum: string;
+    fields: SchemaResponse;
+    block_type_id: string;
+    block_type: BlockTypeResponse;
+    capabilities: string[];
+};

package/dist/types/src/models/api/BlockTypeFilterRequest.d.ts

@@ -0,0 +1,9 @@
+export type BlockTypeFilterRequest = {
+    block_schemas?: {
+        block_capabilities?: {
+            all_?: string[];
+        };
+    };
+    limit?: number;
+    offset?: number;
+};

package/dist/types/src/models/api/BlockTypeResponse.d.ts

@@ -0,0 +1,11 @@
+export type BlockTypeResponse = {
+    id: string;
+    created: string;
+    updated: string;
+    name: string;
+    slug: string;
+    logo_url: string | null;
+    documentation_url: string | null;
+    description: string | null;
+    code_example: string | null;
+};

package/dist/types/src/models/api/ConcurrencyLimitCreateRequest.d.ts

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

package/dist/types/src/models/api/ConcurrencyLimitResponse.d.ts

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

package/dist/types/src/models/api/CreatedOrUpdatedByResponse.d.ts

@@ -0,0 +1,6 @@
+import { CreatedOrUpdatedByType } from '../../models/CreatedOrUpdatedBy';
+export type CreatedOrUpdatedByResponse = {
+    id: string;
+    display_value: string;
+    type: CreatedOrUpdatedByType;
+};

package/dist/types/src/models/api/DeploymentFlowRunRequest.d.ts

@@ -0,0 +1,13 @@
+import { StateRequest } from '../../models/api/StateRequest';
+import { SchemaValues } from '../../types/schemas';
+export type DeploymentFlowRunRequest = Partial<{
+    name: string | null;
+    parameters: SchemaValues;
+    idempotency_key: string | null;
+    context: unknown;
+    empirical_policy: unknown;
+    tags: string[] | null;
+    parent_task_run_id: string | null;
+    infrastructure_document_id: string | null;
+    state: Partial<StateRequest>;
+}>;

package/dist/types/src/models/api/DeploymentResponse.d.ts

@@ -0,0 +1,29 @@
+import { CreatedOrUpdatedByResponse } from '../../models/api/CreatedOrUpdatedByResponse';
+import { ScheduleResponse } from '../../models/api/ScheduleResponse';
+import { SchemaResponse } from '../../models/api/SchemaResponse';
+import { DateString } from '../../types/dates';
+import { SchemaValues } from '../../types/schemas';
+export type DeploymentResponse = {
+    id: string;
+    created: DateString;
+    created_by: CreatedOrUpdatedByResponse | null;
+    updated: DateString;
+    updated_by: CreatedOrUpdatedByResponse | null;
+    name: string;
+    version: string;
+    description: string | null;
+    flow_id: string;
+    schedule: ScheduleResponse | null;
+    is_schedule_active: boolean;
+    parameters: SchemaValues;
+    tags: string[] | null;
+    manifest_path: string | null;
+    path: string | null;
+    entrypoint: string | null;
+    parameter_openapi_schema: SchemaResponse | null;
+    storage_document_id: string | null;
+    infrastructure_document_id: string | null;
+    infra_overrides: Record<string, unknown> | null;
+    work_queue_name: string | null;
+    work_pool_name: string | null;
+};

package/dist/types/src/models/api/DeploymentUpdateRequest.d.ts

@@ -0,0 +1,15 @@
+import { ScheduleResponse } from '../../models';
+import { SchemaValues } from '../../types/schemas';
+export type DeploymentUpdateRequest = Partial<{
+    name: string | null;
+    description: string | null;
+    flow_id: string | null;
+    schedule: ScheduleResponse | null;
+    is_schedule_active: boolean;
+    parameters: SchemaValues | null;
+    tags: string[] | null;
+    storage_document_id: string | null;
+    infrastructure_document_id: string | null;
+    work_queue_name: string | null;
+    work_pool_name: string | null;
+}>;

package/dist/types/src/models/api/EmpiricalPolicyRequest.d.ts

@@ -0,0 +1,6 @@
+export type EmpiricalPolicyRequest = {
+    retries: number | null;
+    retry_delay: number | null;
+    pause_keys: unknown[];
+    resuming: boolean | null;
+};

package/dist/types/src/models/api/EmpiricalPolicyResponse.d.ts

@@ -0,0 +1,6 @@
+export type EmpiricalPolicyResponse = {
+    retries: number | null;
+    retry_delay: number | null;
+    max_retries: number | null;
+    retry_delay_seconds: number | null;
+};

package/dist/types/src/models/api/FlowResponse.d.ts

@@ -0,0 +1,7 @@
+export type FlowResponse = {
+    created: string;
+    id: string;
+    name: string;
+    description: string;
+    updated: string;
+};

package/dist/types/src/models/api/FlowRunGraphResponse.d.ts

@@ -0,0 +1,17 @@
+import { StateResponse } from '../../models/api/StateResponse';
+import { TaskRunInputType } from '../../models/GraphNode';
+import { DateString } from '../../types/dates';
+export type FlowRunGraphResponse = {
+    id: string;
+    name?: string;
+    upstream_dependencies: {
+        id: string;
+        input_type: TaskRunInputType;
+    }[];
+    state: StateResponse;
+    expected_start_time: DateString | null;
+    start_time: DateString | null;
+    end_time: DateString | null;
+    total_run_time: number | null;
+    estimated_run_time: number | null;
+};

package/dist/types/src/models/api/FlowRunHistoryResponse.d.ts

@@ -0,0 +1,6 @@
+import { StateHistoryResponse } from '../../models/api/StateHistoryResponse';
+export type FlowRunHistoryResponse = {
+    interval_start: string;
+    interval_end: string;
+    states: StateHistoryResponse[];
+};