type Map = (...args: any) => any;
type Maps = Record<string, Record<string, Map>>;
type MapsMember<T extends Maps, S extends keyof T> = T[S][keyof T[S]];
type Mappers<T extends Maps, S extends keyof T> = Extract<MapsMember<T, S>, Map>;
type MapperSourceType<T extends Maps, S extends keyof T> = Parameters<Mappers<T, S>>[0];
type MapperDestinationType<T extends Maps, S extends keyof T, D extends keyof T[S]> = ReturnType<T[S][D]>;
export declare class Mapper<T extends Maps> {
    private readonly mapperFunctions;
    constructor(mapperFunctions: T);
    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>, destination: D): MapperDestinationType<T, S, D>;
    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null, destination: D): MapperDestinationType<T, S, D> | null;
    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | undefined, destination: D): MapperDestinationType<T, S, D> | undefined;
    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null | undefined, destination: D): MapperDestinationType<T, S, D> | null | undefined;
    map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>[], destination: D): MapperDestinationType<T, S, D>[];
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>>, destination: D): Record<string, MapperDestinationType<T, S, D>>;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null, destination: D): Record<string, MapperDestinationType<T, S, D>> | null;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | undefined;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | null | undefined;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]>, destination: D): Record<string, MapperDestinationType<T, S, D>[]>;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | undefined;
    mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null | undefined;
    private bindMapper;
}
export declare const mapper: Mapper<{
    ArtifactFilter: {
        ArtifactFilterRequest: MapFunction<import("..").ArtifactFilter, import("../models/api/Filters").ArtifactFilterRequest>;
    };
    ArtifactResponse: {
        Artifact: MapFunction<import("..").ArtifactResponse, import("..").Artifact>;
    };
    ArtifactCollectionResponse: {
        ArtifactCollection: MapFunction<import("../models/api/ArtifactCollectionResponse").ArtifactCollectionResponse, import("..").ArtifactCollection>;
    };
    ArtifactsFilter: {
        ArtifactsFilterRequest: MapFunction<import("..").ArtifactsFilter, import("../models/api/Filters").ArtifactsFilterRequest>;
    };
    AutomationResponse: {
        Automation: MapFunction<import("..").AutomationResponse, import("..").Automation>;
    };
    AutomationActionResponse: {
        AutomationAction: MapFunction<import("..").AutomationActionResponse, import("..").AutomationAction>;
    };
    AutomationAction: {
        AutomationActionRequest: MapFunction<import("..").AutomationAction, import("..").AutomationActionResponse>;
    };
    BlockDocument: {
        SelectOption: MapFunction<import("..").BlockDocument, import("@prefecthq/prefect-design").SelectOption>;
    };
    BlockDocumentCreate: {
        BlockDocumentCreateRequest: MapFunction<import("..").BlockDocumentCreate, import("..").BlockDocumentCreateRequest>;
    };
    BlockDocumentFilter: {
        BlockDocumentFilterRequest: MapFunction<import("..").BlockDocumentFilter, import("../models/api/Filters").BlockDocumentFilterRequest>;
    };
    BlockDocumentReferencesResponse: {
        BlockDocumentReferences: MapFunction<import("..").BlockDocumentReferencesResponse, import("..").BlockDocumentReferences>;
    };
    BlockDocumentResponse: {
        BlockDocument: MapFunction<import("..").BlockDocumentResponse, import("..").BlockDocument>;
    };
    BlockDocumentsFilter: {
        BlockDocumentsFilterRequest: MapFunction<import("..").BlockDocumentsFilter, import("../models/api/Filters").BlockDocumentsFilterRequest>;
    };
    BlockDocumentUpdate: {
        BlockDocumentUpdateRequest: MapFunction<import("..").BlockDocumentUpdate, import("..").BlockDocumentUpdateRequest>;
    };
    BlockSchemaFilter: {
        BlockSchemaFilterRequest: MapFunction<import("..").BlockSchemaFilter, import("../models/api/Filters").BlockSchemaFilterRequest>;
    };
    BlockSchemaReferencesResponse: {
        BlockSchemaReferences: MapFunction<import("..").BlockSchemaReferencesResponse, import("..").BlockSchemaReferences>;
    };
    BlockSchemaResponse: {
        BlockSchema: MapFunction<import("..").BlockSchemaResponse, import("..").BlockSchema>;
    };
    BlockSchemasFilter: {
        BlockSchemasFilterRequest: MapFunction<import("..").BlockSchemasFilter, import("../models/api/Filters").BlockSchemasFilterRequest>;
    };
    BlockTypeFilter: {
        BlockTypeFilterRequest: MapFunction<import("..").BlockTypeFilter, import("../models/api/Filters").BlockTypeFilterRequest>;
    };
    BlockTypeResponse: {
        BlockType: MapFunction<import("..").BlockTypeResponse, import("..").BlockType>;
    };
    BlockTypesFilter: {
        BlockTypesFilterRequest: MapFunction<import("..").BlockTypesFilter, import("../models/api/Filters").BlockTypesFilterRequest>;
    };
    CollectionItemResponse: {
        CollectionItem: MapFunction<import("..").CollectionItemResponse, import("..").CollectionItem>;
    };
    CollectionResponse: {
        CollectionItems: MapFunction<import("..").CollectionsResponse, import("..").CollectionItem[]>;
    };
    ConcurrencyLimitCreate: {
        ConcurrencyLimitCreateRequest: MapFunction<import("..").ConcurrencyLimitCreate, import("..").ConcurrencyLimitCreateRequest>;
    };
    ConcurrencyLimitResponse: {
        ConcurrencyLimit: MapFunction<import("..").ConcurrencyLimitResponse, import("..").ConcurrencyLimit>;
    };
    ConcurrencyV2LimitResponse: {
        ConcurrencyV2Limit: MapFunction<import("../models/api/ConcurrencyV2Response").ConcurrencyV2Response, import("..").ConcurrencyV2Limit>;
    };
    ConcurrencyV2LimitCreate: {
        ConcurrencyV2CreateRequest: MapFunction<import("../models/ConcurrencyV2Create").ConcurrencyV2Create, import("../models/api/ConcurrencyV2CreateRequest").ConcurrencyV2CreateRequest>;
    };
    ConcurrencyV2LimitUpdate: {
        ConcurrencyV2UpdateRequest: MapFunction<import("../models/ConcurrencyV2Update").ConcurrencyV2Update, import("../models/api/ConcurrencyV2UpdateRequest").ConcurrencyV2UpdateRequest>;
    };
    CreateAutomationQuery: {
        LocationQuery: MapFunction<import("..").CreateAutomationQuery, import("vue-router").LocationQuery>;
    };
    CreateAutomationTriggerQuery: {
        LocationQuery: MapFunction<import("..").CreateAutomationTriggerQuery, import("vue-router").LocationQuery>;
    };
    CreateAutomationActionQuery: {
        LocationQuery: MapFunction<import("..").CreateAutomationActionQuery, import("vue-router").LocationQuery>;
    };
    CreatedOrUpdatedByResponse: {
        CreatedOrUpdatedBy: MapFunction<import("..").CreatedOrUpdatedByResponse, import("..").CreatedOrUpdatedBy>;
    };
    Date: {
        string: MapFunction<Date, string>;
    };
    DateRangeSelectValue: {
        DateRange: MapFunction<import("@prefecthq/prefect-design").DateRangeSelectValue & {}, import("@prefecthq/prefect-design").DateRangeWithTimeSpan>;
    };
    DeploymentCreate: {
        DeploymentCreateRequest: MapFunction<import("..").DeploymentCreate, import("../models/api/DeploymentCreateRequest").DeploymentCreateRequest>;
    };
    DeploymentFilter: {
        DeploymentFilterRequest: MapFunction<import("..").DeploymentFilter, import("../models/api/Filters").DeploymentFilterRequest>;
    };
    DeploymentsPaginationFilter: {
        DeploymentsPaginationFilterRequest: MapFunction<import("..").DeploymentsPaginationFilter, import("../models/api/Filters").DeploymentsPaginationFilterRequest>;
    };
    DeploymentPaginationResponse: {
        DeploymentsPagination: MapFunction<import("../models/pagination").Paginated<import("..").DeploymentResponse>, import("../models/pagination").Paginated<import("..").Deployment>>;
    };
    DeploymentFlowRunCreateV2: {
        DeploymentFlowRunRequest: 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>;
            work_queue_name: string | null;
            job_variables: Record<string, unknown>;
            enforce_parameter_schema: boolean | null;
        }>>;
    };
    DeploymentResponse: {
        Deployment: MapFunction<import("..").DeploymentResponse, import("..").Deployment>;
    };
    DeploymentScheduleResponse: {
        DeploymentSchedule: MapFunction<import("../models/api/DeploymentScheduleResponse").DeploymentScheduleResponse, import("..").DeploymentSchedule>;
    };
    DeploymentScheduleCreate: {
        DeploymentScheduleCreateRequest: MapFunction<import("..").DeploymentScheduleCreate, import("../models/api/DeploymentScheduleCreateRequest").DeploymentScheduleCreateRequest>;
    };
    DeploymentScheduleUpdate: {
        DeploymentScheduleUpdateRequest: MapFunction<import("..").DeploymentScheduleUpdate, import("../models/api/DeploymentScheduleUpdateRequest").DeploymentScheduleUpdateRequest>;
    };
    DeploymentsFilter: {
        DeploymentsFilterRequest: MapFunction<import("..").DeploymentsFilter, import("../models/api/Filters").DeploymentsFilterRequest>;
    };
    DeploymentStatus: {
        ServerDeploymentStatus: MapFunction<"ready" | "not_ready" | "disabled", "READY" | "NOT_READY" | "DISABLED">;
    };
    DeploymentStatsFilter: {
        FlowRunsFilter: MapFunction<import("../types/deployment").DeploymentStatsFilter, import("..").FlowRunsFilter>;
    };
    DeploymentUpdateV2: {
        DeploymentUpdateRequest: MapFunction<import("..").DeploymentUpdateV2, 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;
            job_variables: Record<string, unknown> | null;
            enforce_parameter_schema: boolean;
            concurrency_limit: number | null;
            concurrency_options: import("../models/api/DeploymentApiConcurrencyOptions").DeploymentApiConcurrencyOptions | null;
        }>>;
    };
    DeploymentVersionIdFilter: {
        DeploymentVersionIdFilterRequest: MapFunction<import("..").DeploymentVersionIdFilter, import("../models/api/Filters").DeploymentVersionIdFilterRequest | undefined>;
    };
    DeploymentVersionInfoFilter: {
        DeploymentVersionInfoFilterRequest: MapFunction<import("..").DeploymentVersionInfoFilter, import("../models/api/Filters").DeploymentVersionInfoFilterRequest | undefined>;
    };
    DeploymentVersionResponse: {
        DeploymentVersion: MapFunction<import("..").DeploymentVersionResponse, import("..").DeploymentVersion>;
    };
    DeploymentVersionInfoResponse: {
        DeploymentVersionInfo: MapFunction<import("..").DeploymentVersionInfoResponse, import("..").DeploymentVersionInfo>;
    };
    EmpiricalPolicy: {
        EmpiricalPolicyResponse: MapFunction<import("..").EmpiricalPolicy, import("..").EmpiricalPolicyResponse>;
        EmpiricalPolicyRequest: MapFunction<import("..").EmpiricalPolicy, import("../models/api/EmpiricalPolicyRequest").EmpiricalPolicyRequest>;
    };
    EmpiricalPolicyResponse: {
        EmpiricalPolicy: MapFunction<import("..").EmpiricalPolicyResponse, import("..").EmpiricalPolicy>;
    };
    Flow: {
        FlowResponse: MapFunction<import("..").Flow, import("..").FlowResponse>;
        AutomationTrigger: MapFunction<import("..").Flow, import("..").AutomationTrigger>;
    };
    FlowFilter: {
        FlowFilterRequest: MapFunction<import("..").FlowFilter, import("../models/api/Filters").FlowFilterRequest>;
    };
    FlowResponse: {
        Flow: MapFunction<import("..").FlowResponse, import("..").Flow>;
    };
    FlowsPaginationResponse: {
        FlowsPagination: MapFunction<import("../models/pagination").Paginated<import("..").FlowResponse>, import("../models/pagination").Paginated<import("..").Flow>>;
    };
    FlowRunFilter: {
        FlowRunFilterRequest: MapFunction<import("..").FlowRunFilter, import("../models/api/Filters").FlowRunFilterRequest>;
    };
    FlowRunHistoryResponse: {
        RunHistory: MapFunction<import("..").FlowRunHistoryResponse, import("..").RunHistory>;
    };
    FlowRunInputKeyset: {
        FlowRunInputKeysetResponse: MapFunction<import("../models/api/FlowRunInputKeysetResponse").FlowRunInputKeysetResponse, import("../models/FlowRunInputKeyset").FlowRunInputKeyset>;
    };
    FlowRunInputKeysetResponse: {
        FlowRunInputKeyset: MapFunction<import("../models/FlowRunInputKeyset").FlowRunInputKeyset, import("../models/api/FlowRunInputKeysetResponse").FlowRunInputKeysetResponse>;
    };
    FlowRunResponse: {
        FlowRun: MapFunction<import("..").FlowRunResponse, import("..").FlowRun>;
    };
    FlowRunsPaginationResponse: {
        FlowRunsPagination: MapFunction<import("../models/pagination").Paginated<import("..").FlowRunResponse>, import("../models/pagination").Paginated<import("..").FlowRun>>;
    };
    TaskRunsPaginationResponse: {
        TaskRunsPagination: MapFunction<import("../models/pagination").Paginated<import("..").TaskRunResponse>, import("../models/pagination").Paginated<import("..").TaskRun>>;
    };
    FlowRunsFilter: {
        FlowRunsFilterRequest: MapFunction<import("..").FlowRunsFilter, import("../models/api/Filters").FlowRunsFilterRequest>;
    };
    FlowRunsPaginationFilter: {
        FlowRunsPaginationFilterRequest: MapFunction<import("..").FlowRunsPaginationFilter, import("../models/api/Filters").FlowRunsPaginationFilterRequest>;
    };
    TaskRunsPaginationFilter: {
        TaskRunsPaginationFilterRequest: MapFunction<import("..").TaskRunsPaginationFilter, import("../models/api/Filters").TaskRunsPaginationFilterRequest>;
    };
    FlowRunsHistoryFilter: {
        FlowRunsHistoryFilterRequest: MapFunction<import("..").FlowRunsHistoryFilter, import("../models/api/Filters").FlowRunsHistoryFilterRequest>;
    };
    FlowsFilter: {
        FlowsFilterRequest: MapFunction<import("..").FlowsFilter, import("../models/api/Filters").FlowsFilterRequest>;
    };
    FlowsPaginationFilter: {
        FlowsPaginationFilterRequest: MapFunction<import("..").FlowsPaginationFilter, import("../models/api/Filters").FlowsPaginationFilterRequest>;
    };
    FlowStatsFilter: {
        FlowRunsFilter: MapFunction<import("..").FlowStatsFilter, import("..").FlowRunsFilter>;
        TaskRunsFilter: MapFunction<import("..").FlowStatsFilter, import("..").TaskRunsFilter>;
    };
    Log: {
        LogResponse: MapFunction<import("..").Log, import("..").LogResponse>;
    };
    LogResponse: {
        Log: MapFunction<import("..").LogResponse, import("..").Log>;
    };
    LogsFilter: {
        LogsFilterRequest: MapFunction<import("..").LogsFilter, import("../models/api/Filters").LogsFilterRequest>;
    };
    NextFlowRunResponse: {
        NextFlowRun: MapFunction<import("../models/api/NextFlowRunResponse").NextFlowRunResponse, import("../models/NextFlowRun").NextFlowRun>;
    };
    NotificationCreate: {
        NotificationCreateRequest: MapFunction<import("..").NotificationCreate, import("..").NotificationCreateRequest>;
    };
    NotificationResponse: {
        Notification: MapFunction<import("..").NotificationResponse, import("..").Notification>;
    };
    NotificationsFilter: {
        NotificationsFilterRequest: MapFunction<import("..").NotificationsFilter, import("../models/api/Filters").NotificationsFilterRequest>;
    };
    NotificationUpdate: {
        NotificationUpdateRequest: MapFunction<import("..").NotificationUpdate, import("..").NotificationUpdateRequest>;
    };
    number: {
        string: MapFunction<number, string>;
    };
    OrchestrationResultResponse: {
        OrchestrationResult: MapFunction<import("../models/api/OrchestrationResultResponse").OrchestrationResultResponse, import("../models/api/OrchestrationResult").OrchestrationResult>;
    };
    PrefectWorkerCollectionResponse: {
        WorkerCollectionItem: MapFunction<import("..").PrefectWorkerCollectionResponse, import("..").WorkerCollectionItem[]>;
    };
    RunGraphDataResponse: {
        RunGraphData: MapFunction<{
            graph: import("../models/api/RunGraphDataResponse").RunGraphDataResponse;
            nestedTaskRunGraphs: boolean;
        }, import("@prefecthq/graphs").RunGraphData>;
    };
    RunGraphNodeResponse: {
        RunGraphNode: MapFunction<import("../models/api/RunGraphDataResponse").RunGraphNodeResponse, import("@prefecthq/graphs").RunGraphNode>;
    };
    RunGraphArtifactResponse: {
        RunGraphArtifact: MapFunction<import("../models/api/RunGraphDataResponse").RunGraphArtifactResponse, import("@prefecthq/graphs").RunGraphArtifact>;
    };
    RunGraphStateResponse: {
        RunGraphStateEvent: MapFunction<import("../models/api/RunGraphDataResponse").RunGraphStateResponse, import("@prefecthq/graphs").RunGraphStateEvent>;
    };
    RunHistory: {
        FlowRunHistoryResponse: MapFunction<import("..").RunHistory, import("..").FlowRunHistoryResponse>;
        DivergingBarChartItem: MapFunction<import("..").RunHistory, import("@prefecthq/vue-charts").DivergingBarChartItem>;
    };
    SavedSearchCreate: {
        SavedSearchCreateRequest: MapFunction<import("..").SavedSearchCreate, import("..").SavedSearchCreateRequest>;
    };
    SavedSearchesFilter: {
        SavedSearchesFilterRequest: MapFunction<import("..").SavedSearchesFilter, import("../models/api/Filters").SavedSearchesFilterRequest>;
    };
    SavedSearchFilter: {
        FlowRunsFilter: MapFunction<import("..").SavedSearchFilter, import("..").FlowRunsFilter>;
        TaskRunsFilter: MapFunction<import("..").SavedSearchFilter, import("..").TaskRunsFilter>;
        LocationQuery: MapFunction<import("..").SavedSearchFilter, import("vue-router").LocationQuery>;
    };
    SavedSearchResponse: {
        SavedSearch: MapFunction<import("..").SavedSearchResponse, import("..").SavedSearch>;
    };
    Schedule: {
        ScheduleResponse: MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
        ScheduleRequest: MapFunction<import("..").Schedule, import("..").ScheduleResponse>;
    };
    ScheduleResponse: {
        Schedule: MapFunction<import("..").ScheduleResponse, import("..").Schedule>;
    };
    SchemaDefinitionsResponse: {
        SchemaDefinitions: MapFunction<import("..").SchemaDefinitionsResponse, import("..").SchemaDefinitions>;
    };
    SchemaPropertiesResponse: {
        SchemaProperties: MapFunction<import("..").SchemaPropertiesResponse, import("..").SchemaProperties>;
    };
    SchemaPropertyResponse: {
        SchemaProperty: MapFunction<import("..").SchemaPropertyResponse, import("..").SchemaProperty>;
    };
    SchemaResponse: {
        Schema: MapFunction<import("..").SchemaResponse, import("..").Schema>;
    };
    SchemaValues: {
        SchemaValuesRequest: MapFunction<{
            values: import("..").SchemaValues;
            schema: import("..").Schema;
        }, import("..").SchemaValues>;
    };
    SchemaValuesResponse: {
        SchemaValues: MapFunction<{
            values: import("..").SchemaValues;
            schema: import("..").Schema;
            references?: import("..").BlockDocumentReferencesResponse;
        }, import("..").SchemaValues>;
    };
    ServerDeploymentStatus: {
        DeploymentStatus: MapFunction<"READY" | "NOT_READY" | "DISABLED", "ready" | "not_ready" | "disabled">;
    };
    ServerStateType: {
        StateType: MapFunction<"COMPLETED" | "FAILED" | "RUNNING" | "PENDING" | "SCHEDULED" | "CANCELLED" | "CANCELLING" | "CRASHED" | "PAUSED", "completed" | "failed" | "running" | "pending" | "scheduled" | "cancelled" | "cancelling" | "crashed" | "paused">;
    };
    ServerWorkPoolStatus: {
        WorkPoolStatus: MapFunction<"PAUSED" | "READY" | "NOT_READY", "paused" | "ready" | "not_ready">;
    };
    ServerWorkPoolWorkerStatus: {
        WorkPoolWorkerStatus: MapFunction<"ONLINE" | "OFFLINE", "online" | "offline">;
    };
    ServiceLevelAgreementResponse: {
        ServiceLevelAgreement: MapFunction<import("..").ServiceLevelAgreementResponse, import("..").ServiceLevelAgreement>;
    };
    State: {
        StateResponse: MapFunction<import("..").State, import("..").StateResponse>;
    };
    StateCreate: {
        StateRequest: MapFunction<import("..").StateCreate, import("..").StateRequest>;
    };
    StateDetails: {
        StateDetailsResponse: MapFunction<import("..").StateDetails, import("..").StateDetailsResponse>;
        StateDetailsRequest: MapFunction<import("..").StateDetails, import("..").StateDetailsRequest>;
    };
    StateDetailsCreate: {
        StateDetailsRequest: MapFunction<Partial<{
            flowRunId: string | null;
            taskRunId: string | null;
            childFlowRunId: string | null;
            scheduledTime: Date | null;
            cacheKey: string | null;
            cacheExpiration: Date | null;
        }>, import("..").StateDetailsRequest>;
    };
    StateDetailsResponse: {
        StateDetails: MapFunction<import("..").StateDetailsResponse, import("..").StateDetails>;
    };
    StateFilter: {
        StateFilterRequest: MapFunction<import("..").StateFilter, import("../models/api/Filters").StateFilterRequest>;
    };
    StateHistory: {
        StateHistoryResponse: MapFunction<import("..").StateHistory, import("..").StateHistoryResponse>;
    };
    StateHistoryResponse: {
        StateHistory: MapFunction<import("..").StateHistoryResponse, import("..").StateHistory>;
    };
    StateResponse: {
        State: MapFunction<import("..").StateResponse, import("..").State>;
    };
    StateType: {
        ServerStateType: MapFunction<"completed" | "failed" | "running" | "pending" | "scheduled" | "cancelled" | "cancelling" | "crashed" | "paused", "COMPLETED" | "FAILED" | "RUNNING" | "PENDING" | "SCHEDULED" | "CANCELLED" | "CANCELLING" | "CRASHED" | "PAUSED">;
    };
    StateUpdate: {
        StateUpdateRequest: MapFunction<import("..").StateUpdate, import("..").StateUpdateRequest>;
    };
    string: {
        Date: MapFunction<string, Date>;
        number: MapFunction<string, number>;
    };
    TagFilter: {
        TagFilterRequest: MapFunction<import("..").TagFilter, import("../models/api/Filters").TagFilterRequest>;
    };
    TaskInput: {
        TaskInputResponse: MapFunction<import("..").TaskInput, import("..").TaskInputResponse>;
    };
    TaskInputResponse: {
        TaskInput: MapFunction<import("..").TaskInputResponse, import("..").TaskInput>;
    };
    TaskRun: {
        TaskRunResponse: MapFunction<import("..").TaskRun, import("..").TaskRunResponse>;
    };
    TaskRunFilter: {
        TaskRunFilterRequest: MapFunction<import("..").TaskRunFilter, import("../models/api/Filters").TaskRunFilterRequest>;
    };
    TaskRunResponse: {
        TaskRun: MapFunction<import("..").TaskRunResponse, import("..").TaskRun>;
    };
    TaskRunsFilter: {
        TaskRunsFilterRequest: MapFunction<import("..").TaskRunsFilter, import("../models/api/Filters").TaskRunsFilterRequest>;
        TaskRunsHistoryFilter: MapFunction<import("..").TaskRunsFilter, import("..").TaskRunsHistoryFilter>;
    };
    TaskRunsHistoryFilter: {
        TaskRunsHistoryFilterRequest: MapFunction<import("..").TaskRunsHistoryFilter, import("../models/api/Filters").TaskRunsHistoryFilterRequest>;
    };
    UiFlowRunHistory: {
        ScatterPlotItem: MapFunction<import("..").UiFlowRunHistory, {
            id: string;
            x: Date;
            y: number;
            itemClass?: string;
        }>;
    };
    UiFlowRunHistoryResponse: {
        UiFlowRunHistory: MapFunction<import("..").UiFlowRunHistoryResponse, import("..").UiFlowRunHistory>;
    };
    UiNextFlowRunByFlowResponse: {
        UiNextFlowRunByFlow: MapFunction<import("../models/UiNextFlowRunByFlowResponse").UiNextFlowRunByFlowResponse, import("../models/UiNextFlowRunByFlow").UiNextFlowRunByFlow>;
    };
    UiTaskRunCountsByStateResponse: {
        UiTaskRunCountsByState: MapFunction<import("../models/api/UiTaskRunCountsByStateResponse").UiTaskRunCountsByStateResponse, import("../models/UiTaskRunCountsByState").UiTaskRunCountsByState>;
    };
    VariableFilter: {
        VariableFilterRequest: MapFunction<import("..").VariableFilter, import("../models/api/Filters").VariableFilterRequest>;
    };
    VariablesFilter: {
        VariablesFilterRequest: MapFunction<import("..").VariablesFilter, import("../models/api/Filters").VariablesFilterRequest>;
    };
    VariableCreate: {
        VariableCreateRequest: MapFunction<import("..").VariableCreate, Partial<{
            name: string | null;
            value: unknown;
            tags: string[] | null;
        }>>;
    };
    VariableEdit: {
        VariableEditRequest: MapFunction<import("..").VariableEdit, Partial<{
            name: string | null;
            value: unknown;
            tags: string[] | null;
        }>>;
    };
    VariableResponse: {
        Variable: MapFunction<import("../models/api/VariableResponse").VariableResponse, import("..").Variable>;
    };
    WorkerScheduledFlowRunResponse: {
        WorkerScheduledFlowRun: MapFunction<import("..").WorkerScheduledFlowRunResponse, import("..").WorkerScheduledFlowRun>;
    };
    WorkerScheduledFlowRuns: {
        WorkerScheduledFlowRunsRequest: MapFunction<Partial<{
            workPoolQueueNames: string[];
            scheduledBefore: string;
            scheduledAfter: string;
            limit: number;
        }>, Partial<{
            work_pool_queue_names: string[];
            scheduled_before: string;
            scheduled_after: string;
            limit: number;
        }>>;
    };
    WorkerSchemaProperty: {
        WorkerSchemaPropertyRequest: MapFunction<{
            values: import("..").SchemaValues;
            schema: import("..").WorkerBaseJobTemplate;
        }, import("..").WorkerBaseJobTemplate>;
    };
    WorkPool: {
        WorkPoolResponse: MapFunction<import("..").WorkPool, import("..").WorkPoolResponse>;
        AutomationTrigger: MapFunction<import("..").WorkPool, import("..").AutomationTrigger>;
    };
    WorkPoolCreate: {
        WorkPoolCreateRequest: MapFunction<Partial<{
            name: string;
            description: string;
            type: string;
            isPaused: boolean;
            concurrencyLimit: number;
            baseJobTemplate: Record<string, unknown>;
            defaultVariableValues: import("..").SchemaValues;
        }>, Partial<{
            name: string;
            description: string;
            type: string;
            is_paused: boolean;
            concurrency_limit: number;
            base_job_template: import("..").BaseJobTemplateRequest;
        }>>;
    };
    WorkPoolEdit: {
        WorkPoolEditRequest: MapFunction<Partial<{
            description: string | null;
            isPaused: boolean;
            concurrencyLimit: number | null;
            baseJobTemplate: import("..").WorkerBaseJobTemplate;
            updatedDefaultVariableValues: import("..").SchemaValues;
        }>, Partial<{
            description: string | null;
            is_paused: boolean;
            concurrency_limit: number | null;
            base_job_template: import("..").BaseJobTemplateRequest;
        }>>;
    };
    WorkPoolFilter: {
        WorkPoolFilterRequest: MapFunction<import("..").WorkPoolFilter, import("../models/api/Filters").WorkPoolFilterRequest>;
    };
    WorkPoolQueue: {
        AutomationTrigger: MapFunction<import("..").WorkPoolQueue, import("..").AutomationTrigger>;
    };
    WorkPoolQueueCreate: {
        WorkPoolQueueCreateRequest: MapFunction<import("..").WorkPoolQueueCreate, import("..").WorkPoolQueueCreateRequest>;
    };
    WorkPoolQueueEdit: {
        WorkPoolQueueEditRequest: MapFunction<import("..").WorkPoolQueueEdit, import("..").WorkPoolQueueEditRequest>;
    };
    WorkPoolQueueFilter: {
        WorkPoolQueueFilterRequest: MapFunction<import("..").WorkPoolQueueFilter, import("../models/api/Filters").WorkPoolQueueFilterRequest>;
    };
    WorkPoolQueueResponse: {
        WorkPoolQueue: MapFunction<import("..").WorkPoolQueueResponse, import("..").WorkPoolQueue>;
    };
    WorkPoolQueuesFilter: {
        WorkPoolQueuesFilterRequest: MapFunction<import("..").WorkPoolQueuesFilter, import("../models/api/Filters").WorkPoolQueuesFilterRequest>;
    };
    WorkPoolResponse: {
        WorkPool: MapFunction<import("..").WorkPoolResponse, import("..").WorkPool>;
    };
    WorkPoolsFilter: {
        WorkPoolsFilterRequest: MapFunction<import("..").WorkPoolsFilter, import("../models/api/Filters").WorkPoolsFilterRequest>;
    };
    WorkPoolStatus: {
        ServerWorkPoolStatus: MapFunction<"paused" | "ready" | "not_ready", "PAUSED" | "READY" | "NOT_READY">;
    };
    WorkPoolWorkerResponse: {
        WorkPoolWorker: MapFunction<import("..").WorkPoolWorkerResponse, import("..").WorkPoolWorker>;
    };
    WorkersFilter: {
        WorkersFilterRequest: MapFunction<import("..").WorkersFilter, import("../models/api/Filters").WorkersFilterRequest>;
    };
    WorkPoolWorkersFilter: {
        WorkPoolWorkersFilterRequest: MapFunction<import("..").WorkPoolWorkersFilter, import("../models/api/Filters").WorkPoolWorkersFilterRequest>;
    };
    WorkPoolWorkersPagination: {
        WorkPoolWorkersPaginationRequest: MapFunction<import("..").WorkPoolWorkersPagination, import("../models/api/Filters").WorkPoolWorkersPaginationRequest>;
    };
    WorkPoolWorkersPaginationResponse: {
        PaginatedWorkPoolWorkers: MapFunction<import("..").WorkPoolWorkerPaginationResponse, import("..").PaginatedWorkPoolWorkers>;
    };
    WorkPoolWorkerStatus: {
        ServerWorkPoolWorkerStatus: MapFunction<"online" | "offline", "ONLINE" | "OFFLINE">;
    };
    WorkspaceDashboardFilter: {
        TaskRunsFilter: MapFunction<import("..").WorkspaceDashboardFilter, import("..").TaskRunsFilter>;
        TaskRunsHistoryFilter: MapFunction<import("..").WorkspaceDashboardFilter, import("..").TaskRunsHistoryFilter>;
        FlowRunsFilter: MapFunction<import("..").WorkspaceDashboardFilter, import("..").FlowRunsFilter>;
        WorkersFilter: MapFunction<import("..").WorkspaceDashboardFilter, import("..").WorkPoolWorkersFilter>;
    };
    TaskRunHistoryStateResponse: {
        TaskRunHistoryState: MapFunction<import("../models/api/TaskRunHistoryResponse").TaskRunHistoryStateResponse, import("..").TaskRunHistoryState>;
    };
    TaskRunHistoryResponse: {
        TaskRunHistory: MapFunction<import("../models/api/TaskRunHistoryResponse").TaskRunHistoryResponse, import("..").TaskRunHistory>;
    };
    AutomationTrigger: {
        DeploymentStatusTrigger: import("../schemas/mapper").MapFunction<import("..").AutomationTriggerEvent, import("..").DeploymentStatusTrigger>;
        AutomationTriggerRequest: MapFunction<import("..").AutomationTrigger, import("..").AutomationTriggerResponse>;
        FlowRunStateTrigger: MapFunction<import("..").AutomationTriggerEvent, import("..").FlowRunStateTrigger>;
        WorkPoolStatusTrigger: MapFunction<import("..").AutomationTriggerEvent, import("..").WorkPoolStatusTrigger>;
        WorkQueueStatusTrigger: MapFunction<import("..").AutomationTriggerEvent, import("..").WorkQueueStatusTrigger>;
    };
    AutomationTriggerEvent: {
        WorkspaceEventsFilter: MapFunction<import("..").AutomationTriggerEvent, import("..").WorkspaceEventsFilter>;
    };
    DeploymentStatusTrigger: {
        AutomationTrigger: import("../schemas/mapper").MapFunction<import("..").DeploymentStatusTrigger, import("..").AutomationTriggerEvent>;
    };
    AutomationTriggerResponse: {
        AutomationTrigger: MapFunction<import("..").AutomationTriggerResponse, import("..").AutomationTrigger>;
    };
    FlowRunStateTrigger: {
        AutomationTrigger: MapFunction<import("..").FlowRunStateTrigger, import("..").AutomationTriggerEvent>;
    };
    WorkPoolStatusTrigger: {
        AutomationTrigger: MapFunction<import("..").WorkPoolStatusTrigger, import("..").AutomationTriggerEvent>;
    };
    WorkQueueStatusTrigger: {
        AutomationTrigger: MapFunction<import("..").WorkQueueStatusTrigger, import("..").AutomationTriggerEvent>;
    };
    WorkspaceEvent: {
        AutomationTrigger: MapFunction<import("..").WorkspaceEvent, import("..").AutomationTrigger>;
    };
    WorkspaceEventResponse: {
        WorkspaceEvent: MapFunction<import("../models/api/workspaceEvents").WorkspaceEventResponse, import("..").WorkspaceEvent>;
    };
    WorkspaceEventsResponse: {
        WorkspaceEvents: MapFunction<import("../models/api/workspaceEvents").WorkspaceEventsResponse, import("..").WorkspaceEvents>;
    };
    WorkspaceEventsCountResponse: {
        WorkspaceEventsCount: MapFunction<import("../models/api/workspaceEvents").WorkspaceEventsCountResponse, import("..").WorkspaceEventsCount>;
        HistogramDataPoint: MapFunction<import("../models/api/workspaceEvents").WorkspaceEventsCountResponse, import("@prefecthq/vue-charts").HistogramDataPoint>;
    };
    WorkspaceEventsFilter: {
        WorkspaceEventsFilterRequest: MapFunction<import("..").WorkspaceEventsFilter, import("../models/api/workspaceEventsFilterRequest").WorkspaceEventsFilterRequest>;
    };
    WorkspaceEventsFilterRequest: {
        WorkspaceEventsFilter: MapFunction<import("../models/api/workspaceEventsFilterRequest").WorkspaceEventsFilterRequest, import("..").PartialWorkspaceEventsFilter>;
    };
    WorkspaceEventsHistory: {
        WorkspaceEventsHistoryRequest: MapFunction<import("..").WorkspaceEventsHistory, import("../models/api/workspaceEventsHistoryRequest").WorkspaceEventsHistoryRequest>;
    };
}>;
export type MapFunction<S, D> = (this: typeof mapper, source: S) => D;
export {};