@prefecthq/prefect-ui-library 1.0.0

package/dist/types/src/localization/locale/en.d.ts

@@ -0,0 +1,93 @@
+export declare const en: {
+    docs: {
+        gettingStarted: string;
+        flows: string;
+        flowRuns: string;
+        blocks: string;
+        workQueues: string;
+        notifications: string;
+        deployments: string;
+        concurrency: string;
+        automations: string;
+        workPools: string;
+        collections: string;
+    };
+    error: {
+        activateDeployment: string;
+        activateNotification: string;
+        activateWorkPool: string;
+        activateWorkPoolQueue: string;
+        activateWorkQueue: string;
+        cancelFlowRun: string;
+        changeFlowRunState: string;
+        changeTaskRunState: string;
+        createBlock: string;
+        createConcurrencyLimit: string;
+        createNotification: string;
+        createSavedSearch: string;
+        createSchedule: string;
+        createWorkPool: string;
+        createWorkPoolQueue: string;
+        createWorkQueue: string;
+        delete: (type: string) => string;
+        deleteSavedSearch: string;
+        pauseDeployment: string;
+        pauseFlowRun: string;
+        pauseNotification: string;
+        pauseWorkPool: string;
+        pauseWorkPoolQueue: string;
+        pauseWorkQueue: string;
+        removeSchedule: string;
+        resumeFlowRun: string;
+        retryRun: string;
+        scheduleFlowRun: string;
+        submitNotification: string;
+        updateBlock: string;
+        updateNotification: string;
+        updateSchedule: string;
+        updateWorkPool: string;
+        updateWorkPoolQueue: string;
+        updateWorkQueue: string;
+    };
+    success: {
+        activateDeployment: string;
+        activateNotification: string;
+        activateWorkPool: string;
+        activateWorkPoolQueue: string;
+        activateWorkQueue: string;
+        cancelFlowRun: string;
+        changeFlowRunState: string;
+        changeTaskRunState: string;
+        createBlock: string;
+        createConcurrencyLimit: string;
+        createNotification: string;
+        createSavedSearch: string;
+        createSchedule: string;
+        createWorkPool: string;
+        createWorkPoolQueue: string;
+        createWorkQueue: string;
+        delete: (type: string) => string;
+        deleteSavedSearch: string;
+        pauseDeployment: string;
+        pauseFlowRun: string;
+        pauseNotification: string;
+        pauseWorkPool: string;
+        pauseWorkPoolQueue: string;
+        pauseWorkQueue: string;
+        removeSchedule: string;
+        resumeFlowRun: string;
+        retryRun: string;
+        scheduleFlowRun: string;
+        updateBlock: string;
+        updateNotification: string;
+        updateSchedule: string;
+        updateWorkPool: string;
+        updateWorkPoolQueue: string;
+        updateWorkQueue: string;
+    };
+    info: {
+        deprecatedWorkQueue: string;
+        deploymentMissingWorkQueue: string;
+        taskInput: string;
+    };
+};

package/dist/types/src/maps/blockDocument.d.ts

@@ -0,0 +1,6 @@
+import { SelectOption } from '@prefecthq/prefect-design';
+import { BlockDocumentResponse } from '../models/api/BlockDocumentResponse';
+import { BlockDocument } from '../models/BlockDocument';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockDocumentResponseToBlockDocument: MapFunction<BlockDocumentResponse, BlockDocument>;
+export declare const mapBlockDocumentToSelectOption: MapFunction<BlockDocument, SelectOption>;

package/dist/types/src/maps/blockDocumentCreate.d.ts

@@ -0,0 +1,4 @@
+import { BlockDocumentCreateRequest } from '../models/api/BlockDocumentCreateRequest';
+import { BlockDocumentCreate } from '../models/BlockDocumentCreate';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockDocumentCreateToBlockDocumentCreateRequest: MapFunction<BlockDocumentCreate, BlockDocumentCreateRequest>;

package/dist/types/src/maps/blockDocumentFilter.d.ts

@@ -0,0 +1,4 @@
+import { BlockDocumentFilterRequest } from '../models/api/BlockDocumentFilterRequest';
+import { BlockDocumentFilter } from '../models/BlockDocumentFilter';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockDocumentFilterToBlockDocumentFilterRequest: MapFunction<BlockDocumentFilter, BlockDocumentFilterRequest>;

package/dist/types/src/maps/blockDocumentReferences.d.ts

@@ -0,0 +1,3 @@
+import { BlockDocumentReferencesResponse, BlockDocumentReferences } from '../models';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockDocumentResponseReferencesToBlockDocumentReferences: MapFunction<BlockDocumentReferencesResponse, BlockDocumentReferences>;

package/dist/types/src/maps/blockDocumentUpdate.d.ts

@@ -0,0 +1,4 @@
+import { BlockDocumentUpdateRequest } from '../models/api/BlockDocumentUpdateRequest';
+import { BlockDocumentUpdate } from '../models/BlockDocumentUpdate';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockDocumentUpdateToBlockDocumentUpdateRequest: MapFunction<BlockDocumentUpdate, BlockDocumentUpdateRequest>;

package/dist/types/src/maps/blockSchema.d.ts

@@ -0,0 +1,4 @@
+import { BlockSchemaResponse } from '../models/api/BlockSchemaResponse';
+import { BlockSchema } from '../models/BlockSchema';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockSchemaResponseToBlockSchema: MapFunction<BlockSchemaResponse, BlockSchema>;

package/dist/types/src/maps/blockSchemaFilter.d.ts

@@ -0,0 +1,4 @@
+import { BlockSchemaFilterRequest } from '../models/api/BlockSchemaFilterRequest';
+import { BlockSchemaFilter } from '../models/BlockSchemaFilter';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockSchemaFilterToBlockSchemaFilterRequest: MapFunction<BlockSchemaFilter, BlockSchemaFilterRequest>;

package/dist/types/src/maps/blockSchemaReferences.d.ts

@@ -0,0 +1,4 @@
+import { BlockSchemaReferencesResponse } from '../models/api/SchemaResponse';
+import { MapFunction } from '../services/Mapper';
+import { BlockSchemaReferences } from '../types/schemas';
+export declare const mapBlockSchemaReferencesResponseToBlockSchemaReferences: MapFunction<BlockSchemaReferencesResponse, BlockSchemaReferences>;

package/dist/types/src/maps/blockType.d.ts

@@ -0,0 +1,4 @@
+import { BlockTypeResponse } from '../models/api/BlockTypeResponse';
+import { BlockType } from '../models/BlockType';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockTypeResponseToBlockType: MapFunction<BlockTypeResponse, BlockType>;

package/dist/types/src/maps/blockTypeFilter.d.ts

@@ -0,0 +1,4 @@
+import { BlockTypeFilterRequest } from '../models/api/BlockTypeFilterRequest';
+import { BlockTypeFilter } from '../models/BlockTypeFilter';
+import { MapFunction } from '../services/Mapper';
+export declare const mapBlockTypeFilterToBlockTypeFilterRequest: MapFunction<BlockTypeFilter, BlockTypeFilterRequest>;

package/dist/types/src/maps/concurrencyLimit.d.ts

@@ -0,0 +1,4 @@
+import { ConcurrencyLimitResponse } from '../models/api/ConcurrencyLimitResponse';
+import { ConcurrencyLimit } from '../models/ConcurrencyLimit';
+import { MapFunction } from '../services/Mapper';
+export declare const mapConcurrencyLimitResponseToConcurrencyLimit: MapFunction<ConcurrencyLimitResponse, ConcurrencyLimit>;

package/dist/types/src/maps/concurrencyLimitCreate.d.ts

@@ -0,0 +1,4 @@
+import { ConcurrencyLimitCreateRequest } from '../models/api/ConcurrencyLimitCreateRequest';
+import { ConcurrencyLimitCreate } from '../models/ConcurrencyLimitCreate';
+import { MapFunction } from '../services/Mapper';
+export declare const mapConcurrencyLimitCreateToConcurrencyLimitCreateRequest: MapFunction<ConcurrencyLimitCreate, ConcurrencyLimitCreateRequest>;

package/dist/types/src/maps/createdOrUpdatedBy.d.ts

@@ -0,0 +1,4 @@
+import { CreatedOrUpdatedByResponse } from '../models/api/CreatedOrUpdatedByResponse';
+import { CreatedOrUpdatedBy } from '../models/CreatedOrUpdatedBy';
+import { MapFunction } from '../services/Mapper';
+export declare const mapCreatedOrUpdatedByResponseToCreatedOrUpdatedBy: MapFunction<CreatedOrUpdatedByResponse, CreatedOrUpdatedBy>;

package/dist/types/src/maps/date.d.ts

@@ -0,0 +1,3 @@
+import { MapFunction } from '../services/Mapper';
+export declare const mapStringToDate: MapFunction<string, Date>;
+export declare const mapDateToString: MapFunction<Date, string>;

package/dist/types/src/maps/deployment.d.ts

@@ -0,0 +1,7 @@
+import { DeploymentFlowRunCreate, DeploymentFlowRunRequest, DeploymentUpdate, DeploymentUpdateRequest } from '../models';
+import { DeploymentResponse } from '../models/api/DeploymentResponse';
+import { Deployment } from '../models/Deployment';
+import { MapFunction } from '../services/Mapper';
+export declare const mapDeploymentResponseToDeployment: MapFunction<DeploymentResponse, Deployment>;
+export declare const mapDeploymentUpdateToDeploymentUpdateRequest: MapFunction<DeploymentUpdate, DeploymentUpdateRequest>;
+export declare const mapDeploymentFlowRunCreateToDeploymentFlowRunRequest: MapFunction<DeploymentFlowRunCreate, DeploymentFlowRunRequest>;

package/dist/types/src/maps/divergingBarChartItem.d.ts

@@ -0,0 +1,4 @@
+import { DivergingBarChartItem } from '@prefecthq/vue-charts';
+import { RunHistory } from '../models/RunHistory';
+import { MapFunction } from '../services/Mapper';
+export declare const mapRunHistoryToDivergingBarChartItem: MapFunction<RunHistory, DivergingBarChartItem>;

package/dist/types/src/maps/empiricalPolicy.d.ts

@@ -0,0 +1,7 @@
+import { EmpiricalPolicyRequest } from '../models/api/EmpiricalPolicyRequest';
+import { EmpiricalPolicyResponse } from '../models/api/EmpiricalPolicyResponse';
+import { EmpiricalPolicy } from '../models/EmpiricalPolicy';
+import { MapFunction } from '../services/Mapper';
+export declare const mapEmpiricalPolicyResponseToEmpiricalPolicy: MapFunction<EmpiricalPolicyResponse, EmpiricalPolicy>;
+export declare const mapEmpiricalPolicyToEmpiricalPolicyResponse: MapFunction<EmpiricalPolicy, EmpiricalPolicyResponse>;
+export declare const mapEmpiricalPolicyToEmpiricalPolicyRequest: MapFunction<EmpiricalPolicy, EmpiricalPolicyRequest>;

package/dist/types/src/maps/flow.d.ts

@@ -0,0 +1,5 @@
+import { FlowResponse } from '../models/api/FlowResponse';
+import { Flow } from '../models/Flow';
+import { MapFunction } from '../services/Mapper';
+export declare const mapFlowResponseToFlow: MapFunction<FlowResponse, Flow>;
+export declare const mapFlowToFlowResponse: MapFunction<Flow, FlowResponse>;

package/dist/types/src/maps/flowRun.d.ts

@@ -0,0 +1,4 @@
+import { FlowRunResponse } from '../models/api/FlowRunResponse';
+import { FlowRun } from '../models/FlowRun';
+import { MapFunction } from '../services/Mapper';
+export declare const mapFlowRunResponseToFlowRun: MapFunction<FlowRunResponse, FlowRun>;

package/dist/types/src/maps/flowRunFilter.d.ts

@@ -0,0 +1,4 @@
+import { SavedSearchFilter } from '../models/SavedSearch';
+import { MapFunction } from '../services/Mapper';
+import { FlowRunFilters } from '../types/filter';
+export declare const mapSavedSearchFilterToFlowRunFilters: MapFunction<SavedSearchFilter, FlowRunFilters>;

package/dist/types/src/maps/flowRunGraph.d.ts

@@ -0,0 +1,5 @@
+import { FlowRunGraphResponse } from '../models/api/FlowRunGraphResponse';
+import { GraphNode } from '../models/GraphNode';
+import { MapFunction } from '../services/Mapper';
+export declare const mapFlowRunGraphResponseToGraphNode: MapFunction<FlowRunGraphResponse, GraphNode>;
+export declare const mapGraphNodeToFlowRunGraphResponse: MapFunction<GraphNode, FlowRunGraphResponse>;

package/dist/types/src/maps/flowRunHistory.d.ts

@@ -0,0 +1,5 @@
+import { FlowRunHistoryResponse } from '../models/api/FlowRunHistoryResponse';
+import { RunHistory } from '../models/RunHistory';
+import { MapFunction } from '../services/Mapper';
+export declare const mapFlowRunHistoryResponseToRunHistory: MapFunction<FlowRunHistoryResponse, RunHistory>;
+export declare const mapRunHistoryToFlowRunHistoryResponse: MapFunction<RunHistory, FlowRunHistoryResponse>;

package/dist/types/src/maps/flowRunTimeline.d.ts

@@ -0,0 +1,4 @@
+import { FlowRunGraphResponse } from '../models/api/FlowRunGraphResponse';
+import { TimelineNode } from '../models/TimelineNode';
+import { MapFunction } from '../services/Mapper';
+export declare const mapFlowRunGraphResponseToTimelineNode: MapFunction<FlowRunGraphResponse, TimelineNode>;

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

@@ -0,0 +1,347 @@
+export declare const maps: {
+    BlockDocument: {
+        SelectOption: import("..").MapFunction<import("..").BlockDocument, import("@prefecthq/prefect-design").SelectOption>;
+    };
+    BlockDocumentCreate: {
+        BlockDocumentCreateRequest: import("..").MapFunction<import("..").BlockDocumentCreate, import("..").BlockDocumentCreateRequest>;
+    };
+    BlockDocumentFilter: {
+        BlockDocumentFilterRequest: import("..").MapFunction<import("..").BlockDocumentFilter, import("..").BlockDocumentFilterRequest>;
+    };
+    BlockDocumentReferencesResponse: {
+        BlockDocumentReferences: import("..").MapFunction<import("..").BlockDocumentReferencesResponse, import("..").BlockDocumentReferences>;
+    };
+    BlockDocumentResponse: {
+        BlockDocument: import("..").MapFunction<import("..").BlockDocumentResponse, import("..").BlockDocument>;
+    };
+    BlockDocumentUpdate: {
+        BlockDocumentUpdateRequest: import("..").MapFunction<import("..").BlockDocumentUpdate, import("..").BlockDocumentUpdateRequest>;
+    };
+    BlockSchemaFilter: {
+        BlockSchemaFilterRequest: import("..").MapFunction<import("..").BlockSchemaFilter, import("..").BlockSchemaFilterRequest>;
+    };
+    BlockSchemaReferencesResponse: {
+        BlockSchemaReferences: import("..").MapFunction<import("..").BlockSchemaReferencesResponse, import("..").BlockSchemaReferences>;
+    };
+    BlockSchemaResponse: {
+        BlockSchema: import("..").MapFunction<import("..").BlockSchemaResponse, import("..").BlockSchema>;
+    };
+    BlockTypeFilter: {
+        BlockTypeFilterRequest: import("..").MapFunction<import("..").BlockTypeFilter, import("..").BlockTypeFilterRequest>;
+    };
+    BlockTypeResponse: {
+        BlockType: import("..").MapFunction<import("..").BlockTypeResponse, import("..").BlockType>;
+    };
+    ConcurrencyLimitCreate: {
+        ConcurrencyLimitCreateRequest: import("..").MapFunction<import("..").ConcurrencyLimitCreate, import("..").ConcurrencyLimitCreateRequest>;
+    };
+    ConcurrencyLimitResponse: {
+        ConcurrencyLimit: import("..").MapFunction<import("..").ConcurrencyLimitResponse, import("..").ConcurrencyLimit>;
+    };
+    CreatedOrUpdatedByResponse: {
+        CreatedOrUpdatedBy: import("..").MapFunction<import("..").CreatedOrUpdatedByResponse, import("..").CreatedOrUpdatedBy>;
+    };
+    Date: {
+        string: import("..").MapFunction<Date, string>;
+    };
+    DeploymentFlowRunCreate: {
+        DeploymentFlowRunRequest: import("..").MapFunction<import("..").DeploymentFlowRunCreate, Partial<{
+            name: string | null;
+            parameters: import("..").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<import("..").StateRequest>;
+        }>>;
+    };
+    DeploymentResponse: {
+        Deployment: import("..").MapFunction<import("..").DeploymentResponse, import("..").Deployment>;
+    };
+    DeploymentUpdate: {
+        DeploymentUpdateRequest: import("..").MapFunction<import("..").DeploymentUpdate, Partial<{
+            name: string | null;
+            description: string | null;
+            flow_id: string | null;
+            schedule: import("..").ScheduleResponse | null;
+            is_schedule_active: boolean;
+            parameters: import("..").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;
+        }>>;
+    };
+    EmpiricalPolicy: {
+        EmpiricalPolicyResponse: import("..").MapFunction<import("..").EmpiricalPolicy, import("..").EmpiricalPolicyResponse>;
+        EmpiricalPolicyRequest: import("..").MapFunction<import("..").EmpiricalPolicy, import("../models/api/EmpiricalPolicyRequest").EmpiricalPolicyRequest>;
+    };
+    EmpiricalPolicyResponse: {
+        EmpiricalPolicy: import("..").MapFunction<import("..").EmpiricalPolicyResponse, import("..").EmpiricalPolicy>;
+    };
+    Flow: {
+        FlowResponse: import("..").MapFunction<import("..").Flow, import("..").FlowResponse>;
+    };
+    FlowResponse: {
+        Flow: import("..").MapFunction<import("..").FlowResponse, import("..").Flow>;
+    };
+    FlowRunGraphResponse: {
+        GraphNode: import("..").MapFunction<import("..").FlowRunGraphResponse, import("..").GraphNode>;
+        TimelineNode: import("..").MapFunction<import("..").FlowRunGraphResponse, import("..").TimelineNode>;
+    };
+    FlowRunHistoryResponse: {
+        RunHistory: import("..").MapFunction<import("..").FlowRunHistoryResponse, import("..").RunHistory>;
+    };
+    FlowRunResponse: {
+        FlowRun: import("..").MapFunction<import("..").FlowRunResponse, import("..").FlowRun>;
+    };
+    GraphNode: {
+        FlowRunGraphResponse: import("..").MapFunction<import("..").GraphNode, import("..").FlowRunGraphResponse>;
+    };
+    Log: {
+        LogResponse: import("..").MapFunction<import("..").Log, import("..").LogResponse>;
+    };
+    LogResponse: {
+        Log: import("..").MapFunction<import("..").LogResponse, import("..").Log>;
+    };
+    NotificationCreate: {
+        NotificationCreateRequest: import("..").MapFunction<import("..").NotificationCreate, import("..").NotificationCreateRequest>;
+    };
+    NotificationResponse: {
+        Notification: import("..").MapFunction<import("..").NotificationResponse, import("..").Notification>;
+    };
+    NotificationUpdate: {
+        NotificationUpdateRequest: import("..").MapFunction<import("..").NotificationUpdate, import("..").NotificationUpdateRequest>;
+    };
+    number: {
+        string: import("..").MapFunction<number, string>;
+    };
+    RunHistory: {
+        FlowRunHistoryResponse: import("..").MapFunction<import("..").RunHistory, import("..").FlowRunHistoryResponse>;
+        DivergingBarChartItem: import("..").MapFunction<import("..").RunHistory, import("@prefecthq/vue-charts").DivergingBarChartItem<Record<string, number>>>;
+    };
+    SavedSearchCreate: {
+        SavedSearchCreateRequest: import("..").MapFunction<import("..").SavedSearchCreate, import("..").SavedSearchCreateRequest>;
+    };
+    SavedSearchFilter: {
+        FlowRunFilters: import("..").MapFunction<import("..").SavedSearchFilter, import("../types/filter").FlowRunFilters>;
+    };
+    SavedSearchResponse: {
+        SavedSearch: import("..").MapFunction<import("..").SavedSearchResponse, import("..").SavedSearch>;
+    };
+    Schedule: {
+        ScheduleResponse: import("..").MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
+        ScheduleRequest: import("..").MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
+    };
+    ScheduleResponse: {
+        Schedule: import("..").MapFunction<import("..").ScheduleResponse, import("..").Schedule>;
+    };
+    SchemaDefinitionsResponse: {
+        SchemaDefinitions: import("..").MapFunction<import("..").SchemaDefinitionsResponse, import("..").SchemaDefinitions>;
+    };
+    SchemaPropertiesResponse: {
+        SchemaProperties: import("..").MapFunction<import("..").SchemaPropertiesResponse, import("..").SchemaProperties>;
+    };
+    SchemaPropertyResponse: {
+        SchemaProperty: import("..").MapFunction<import("..").SchemaPropertyResponse, import("..").SchemaProperty>;
+    };
+    SchemaResponse: {
+        Schema: import("..").MapFunction<import("..").SchemaResponse, import("..").Schema>;
+    };
+    SchemaValues: {
+        SchemaValuesRequest: import("..").MapFunction<{
+            values: import("..").SchemaValues;
+            schema: import("..").Schema;
+        }, import("..").SchemaValues>;
+    };
+    SchemaValuesResponse: {
+        SchemaValues: import("..").MapFunction<{
+            values: import("..").SchemaValues;
+            schema: import("..").Schema;
+            references?: import("..").BlockDocumentReferencesResponse | undefined;
+        }, import("..").SchemaValues>;
+    };
+    ServerStateType: {
+        StateType: import("..").MapFunction<"COMPLETED" | "RUNNING" | "SCHEDULED" | "PENDING" | "FAILED" | "CANCELLED" | "CRASHED" | "PAUSED", "completed" | "running" | "scheduled" | "pending" | "failed" | "cancelled" | "crashed" | "paused">;
+    };
+    State: {
+        StateResponse: import("..").MapFunction<import("..").State, import("..").StateResponse>;
+    };
+    StateCreate: {
+        StateRequest: import("..").MapFunction<import("..").StateCreate, import("..").StateRequest>;
+    };
+    StateDetails: {
+        StateDetailsResponse: import("..").MapFunction<import("..").StateDetails, import("..").StateDetailsResponse>;
+        StateDetailsRequest: import("..").MapFunction<import("..").StateDetails, import("..").StateDetailsRequest>;
+    };
+    StateDetailsCreate: {
+        StateDetailsRequest: import("..").MapFunction<Partial<{
+            flowRunId: string | null;
+            taskRunId: string | null;
+            childFlowRunId: string | null;
+            scheduledTime: Date | null;
+            cacheKey: string | null;
+            cacheExpiration: Date | null;
+        }>, import("..").StateDetailsRequest>;
+    };
+    StateDetailsResponse: {
+        StateDetails: import("..").MapFunction<import("..").StateDetailsResponse, import("..").StateDetails>;
+    };
+    StateHistory: {
+        StateHistoryResponse: import("..").MapFunction<import("..").StateHistory, import("..").StateHistoryResponse>;
+    };
+    StateHistoryResponse: {
+        StateHistory: import("..").MapFunction<import("..").StateHistoryResponse, import("..").StateHistory>;
+    };
+    StateResponse: {
+        State: import("..").MapFunction<import("..").StateResponse, import("..").State>;
+    };
+    StateType: {
+        ServerStateType: import("..").MapFunction<"completed" | "running" | "scheduled" | "pending" | "failed" | "cancelled" | "crashed" | "paused", "COMPLETED" | "RUNNING" | "SCHEDULED" | "PENDING" | "FAILED" | "CANCELLED" | "CRASHED" | "PAUSED">;
+    };
+    StateUpdate: {
+        StateUpdateRequest: import("..").MapFunction<import("..").StateUpdate, import("..").StateUpdateRequest>;
+    };
+    string: {
+        Date: import("..").MapFunction<string, Date>;
+        number: import("..").MapFunction<string, number>;
+    };
+    TaskInput: {
+        TaskInputResponse: import("..").MapFunction<import("..").TaskInput, import("..").TaskInputResponse>;
+    };
+    TaskInputResponse: {
+        TaskInput: import("..").MapFunction<import("..").TaskInputResponse, import("..").TaskInput>;
+    };
+    TaskRun: {
+        TaskRunResponse: import("..").MapFunction<import("..").TaskRun, import("..").TaskRunResponse>;
+    };
+    TaskRunResponse: {
+        TaskRun: import("..").MapFunction<import("..").TaskRunResponse, import("..").TaskRun>;
+    };
+    UiFlowRunHistory: {
+        ScatterPlotItem: import("..").MapFunction<import("..").UiFlowRunHistory, {
+            id: string;
+            x: Date;
+            y: number;
+            itemClass?: string | undefined;
+        }>;
+    };
+    UiFlowRunHistoryResponse: {
+        UiFlowRunHistory: import("..").MapFunction<import("..").UiFlowRunHistoryResponse, import("..").UiFlowRunHistory>;
+    };
+    WorkerScheduledFlowRunResponse: {
+        WorkerScheduledFlowRun: import("..").MapFunction<import("..").WorkerScheduledFlowRunResponse, import("..").WorkerScheduledFlowRun>;
+    };
+    WorkerScheduledFlowRuns: {
+        WorkerScheduledFlowRunsRequest: import("..").MapFunction<Partial<{
+            workPoolQueueNames: string[];
+            scheduledBefore: string;
+            scheduledAfter: string;
+            limit: number;
+        }>, Partial<{
+            work_pool_queue_names: string[];
+            scheduled_before: string;
+            scheduled_after: string;
+            limit: number;
+        }>>;
+    };
+    WorkPool: {
+        WorkPoolResponse: import("..").MapFunction<import("..").WorkPool, import("..").WorkPoolResponse>;
+    };
+    WorkPoolCreate: {
+        WorkPoolCreateRequest: import("..").MapFunction<Partial<{
+            name: string;
+            description: string;
+            type: string;
+            isPaused: boolean;
+            concurrencyLimit: number;
+        }>, Partial<{
+            name: string;
+            description: string;
+            type: string;
+            is_paused: boolean;
+            concurrency_limit: number;
+        }>>;
+    };
+    WorkPoolEdit: {
+        WorkPoolEditRequest: import("..").MapFunction<Partial<{
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+        }>, Partial<{
+            description: string | null;
+            is_paused: boolean;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkPoolQueue: {
+        WorkPoolQueueResponse: import("..").MapFunction<import("..").WorkPoolQueue, import("..").WorkPoolQueueResponse>;
+    };
+    WorkPoolQueueCreate: {
+        WorkPoolQueueCreateRequest: import("..").MapFunction<Partial<{
+            name: string;
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+            priority: number;
+        }>, Partial<{
+            name: string;
+            description: string | null;
+            is_paused: boolean;
+            concurrency_limit: number | null;
+            priority: number;
+        }>>;
+    };
+    WorkPoolQueueEdit: {
+        WorkPoolQueueEditRequest: import("..").MapFunction<import("..").WorkPoolQueueEdit, import("..").WorkPoolQueueEditRequest>;
+    };
+    WorkPoolQueueResponse: {
+        WorkPoolQueue: import("..").MapFunction<import("..").WorkPoolQueueResponse, import("..").WorkPoolQueue>;
+    };
+    WorkPoolResponse: {
+        WorkPool: import("..").MapFunction<import("..").WorkPoolResponse, import("..").WorkPool>;
+    };
+    WorkPoolWorkerResponse: {
+        WorkPoolWorker: import("..").MapFunction<import("..").WorkPoolWorkerResponse, import("..").WorkPoolWorker>;
+    };
+    WorkQueue: {
+        WorkQueueResponse: import("..").MapFunction<import("..").WorkQueue, import("..").WorkQueueResponse>;
+    };
+    WorkQueueCreate: {
+        WorkQueueCreateRequest: import("..").MapFunction<import("..").WorkQueueCreate, Partial<{
+            name: string | null;
+            description: string | null;
+            is_paused: boolean | null;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkQueueEdit: {
+        WorkQueueEditRequest: import("..").MapFunction<Partial<{
+            description: string | null;
+            isPaused: boolean;
+            concurrencyLimit: number | null;
+        }>, Partial<{
+            description: string | null;
+            is_paused: boolean | null;
+            concurrency_limit: number | null;
+        }>>;
+    };
+    WorkQueueFilter: {
+        WorkQueueFilterResponse: import("..").MapFunction<import("..").WorkQueueFilter, import("..").WorkQueueFilterResponse>;
+    };
+    WorkQueueFilterResponse: {
+        WorkQueueFilter: import("..").MapFunction<import("..").WorkQueueFilterResponse, import("..").WorkQueueFilter>;
+    };
+    WorkQueueHealthPolicyResponse: {
+        WorkQueueHealthPolicy: import("..").MapFunction<import("..").WorkQueueHealthPolicyResponse, import("..").WorkQueueHealthPolicy>;
+    };
+    WorkQueueResponse: {
+        WorkQueue: import("..").MapFunction<import("..").WorkQueueResponse, import("..").WorkQueue>;
+    };
+    WorkQueueStatusResponse: {
+        WorkQueueStatus: import("..").MapFunction<import("..").WorkQueueStatusResponse, import("..").WorkQueueStatus>;
+    };
+};

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

@@ -0,0 +1,5 @@
+import { LogResponse } from '../models/api/LogResponse';
+import { Log } from '../models/Log';
+import { MapFunction } from '../services/Mapper';
+export declare const mapLogResponseToLog: MapFunction<LogResponse, Log>;
+export declare const mapLogToLogResponse: MapFunction<Log, LogResponse>;

package/dist/types/src/maps/notification.d.ts

@@ -0,0 +1,4 @@
+import { NotificationResponse } from '../models/api/NotificationResponse';
+import { Notification } from '../models/Notification';
+import { MapFunction } from '../services/Mapper';
+export declare const mapNotificationResponseToNotification: MapFunction<NotificationResponse, Notification>;

package/dist/types/src/maps/notificationCreate.d.ts

@@ -0,0 +1,4 @@
+import { NotificationCreateRequest } from '../models/api/NotificationCreateRequest';
+import { NotificationCreate } from '../models/NotificationCreate';
+import { MapFunction } from '../services/Mapper';
+export declare const mapNotificationCreateToNotificationCreateRequest: MapFunction<NotificationCreate, NotificationCreateRequest>;

package/dist/types/src/maps/notificationUpdate.d.ts

@@ -0,0 +1,4 @@
+import { NotificationUpdateRequest } from '../models/api/NotificationUpdateRequest';
+import { NotificationUpdate } from '../models/NotificationUpdate';
+import { MapFunction } from '../services/Mapper';
+export declare const mapNotificationUpdateToNotificationUpdateRequest: MapFunction<NotificationUpdate, NotificationUpdateRequest>;

package/dist/types/src/maps/number.d.ts

@@ -0,0 +1,3 @@
+import { MapFunction } from '../services/Mapper';
+export declare const mapStringToNumber: MapFunction<string, number>;
+export declare const mapNumberToString: MapFunction<number, string>;

package/dist/types/src/maps/savedSearch.d.ts

@@ -0,0 +1,4 @@
+import { SavedSearchResponse } from '../models/api/SavedSearchResponse';
+import { SavedSearch } from '../models/SavedSearch';
+import { MapFunction } from '../services/Mapper';
+export declare const mapSavedSearchResponseToSavedSearch: MapFunction<SavedSearchResponse, SavedSearch>;

package/dist/types/src/maps/savedSearchCreate.d.ts

@@ -0,0 +1,4 @@
+import { SavedSearchCreateRequest } from '../models/api/SavedSearchResponse';
+import { SavedSearchCreate } from '../models/SavedSearch';
+import { MapFunction } from '../services/Mapper';
+export declare const mapSavedSearchCreateToSavedSearchCreateRequest: MapFunction<SavedSearchCreate, SavedSearchCreateRequest>;

package/dist/types/src/maps/scatterPlotItem.d.ts

@@ -0,0 +1,10 @@
+import { UiFlowRunHistory } from '../models/UiFlowRunHistory';
+import { MapFunction } from '../services/Mapper';
+type ScatterPlotItem = {
+    id: string;
+    x: Date;
+    y: number;
+    itemClass?: string;
+};
+export declare const mapUiFlowRunHistoryToScatterPlotItem: MapFunction<UiFlowRunHistory, ScatterPlotItem>;
+export {};