@evolver-fi/evolver-basics-admin-components 0.0.21 → 8.2.2-alpha.2

package/dist/types/routes/message-log/api.d.ts

@@ -0,0 +1,88 @@
+import { ApiClient } from '../../client';
+import { paths } from '../../types/openapiTypes';
+type OpenApiFetchMessageLogsQuery = NonNullable<paths["/log"]["get"]["parameters"]["query"]>;
+export type FetchMessageLogsQuery = OpenApiFetchMessageLogsQuery;
+export type MessageLogStringFilterValue = NonNullable<FetchMessageLogsQuery["v"]>[number];
+export type MessageLogIntFilterValue = NonNullable<FetchMessageLogsQuery["mci"]>[number];
+export declare const fetchMessageLogs: (query: FetchMessageLogsQuery, client: ApiClient) => Promise<{
+    content?: {
+        address?: string | undefined;
+        appServer?: string | undefined;
+        appVersion?: string | undefined;
+        dataDirection?: "OUTBOUND" | "INBOUND" | undefined;
+        durationMs?: number | undefined;
+        id?: number | undefined;
+        messageChainId?: number | undefined;
+        messageType?: string | undefined;
+        metadata?: {
+            [x: string]: string;
+        } | undefined;
+        protocol?: string | undefined;
+        requestHeaders?: string | undefined;
+        requestSize?: number | undefined;
+        requestingSystem?: string | undefined;
+        respondingSystem?: string | undefined;
+        responseHeaders?: string | undefined;
+        responseSize?: number | undefined;
+        startTime?: string | undefined;
+        statusCode?: string | undefined;
+        statusMessage?: string | undefined;
+    }[] | undefined;
+    empty?: boolean | undefined;
+    first?: boolean | undefined;
+    last?: boolean | undefined;
+    number?: number | undefined;
+    numberOfElements?: number | undefined;
+    pageable?: {
+        offset?: number | undefined;
+        pageNumber?: number | undefined;
+        pageSize?: number | undefined;
+        paged?: boolean | undefined;
+        sort?: {
+            empty?: boolean | undefined;
+            sorted?: boolean | undefined;
+            unsorted?: boolean | undefined;
+        } | undefined;
+        unpaged?: boolean | undefined;
+    } | undefined;
+    size?: number | undefined;
+    sort?: {
+        empty?: boolean | undefined;
+        sorted?: boolean | undefined;
+        unsorted?: boolean | undefined;
+    } | undefined;
+    totalElements?: number | undefined;
+    totalPages?: number | undefined;
+}>;
+export declare const fetchMessageLogById: (id: number, client: ApiClient) => Promise<{
+    address?: string | undefined;
+    appServer?: string | undefined;
+    appVersion?: string | undefined;
+    dataDirection?: "OUTBOUND" | "INBOUND" | undefined;
+    durationMs?: number | undefined;
+    id?: number | undefined;
+    messageChainId?: number | undefined;
+    messageType?: string | undefined;
+    metadata?: {
+        key?: string | undefined;
+        value?: string | undefined;
+    }[] | undefined;
+    protocol?: string | undefined;
+    requestHeaders?: string | undefined;
+    requestMessage?: string | undefined;
+    requestSize?: number | undefined;
+    requestingSystem?: string | undefined;
+    respondingSystem?: string | undefined;
+    responseHeaders?: string | undefined;
+    responseMessage?: string | undefined;
+    responseSize?: number | undefined;
+    startTime?: string | undefined;
+    statusCode?: string | undefined;
+    statusMessage?: string | undefined;
+}>;
+export declare const getLogBodyUrl: (id: number, type: "request" | "response") => string;
+export declare const downloadLogBody: (id: number, type: "request" | "response", client: ApiClient) => Promise<{
+    blob: Blob;
+    contentType: string;
+}>;
+export {};

package/dist/types/routes/message-log/index.d.ts

@@ -0,0 +1,4 @@
+export { getMessageLogLoader, getSingleLogMessageLoader } from './loader';
+export { default as MessageLogListRoute } from './MessageLogRoute';
+export { default as SingleMessageLogRoute } from './SingleLogMessageRoute';
+export { fetchMessageLogs, fetchMessageLogById, getLogBodyUrl, downloadLogBody, type FetchMessageLogsQuery, } from './api';

package/dist/types/routes/message-log/loader.d.ts

@@ -0,0 +1,53 @@
+import { LoaderFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+export declare const getMessageLogLoader: (client: ApiClient) => ({ request }: LoaderFunctionArgs) => Promise<{
+    content?: {
+        address?: string | undefined;
+        appServer?: string | undefined;
+        appVersion?: string | undefined;
+        dataDirection?: "OUTBOUND" | "INBOUND" | undefined;
+        durationMs?: number | undefined;
+        id?: number | undefined;
+        messageChainId?: number | undefined;
+        messageType?: string | undefined;
+        metadata?: {
+            [x: string]: string;
+        } | undefined;
+        protocol?: string | undefined;
+        requestHeaders?: string | undefined;
+        requestSize?: number | undefined;
+        requestingSystem?: string | undefined;
+        respondingSystem?: string | undefined;
+        responseHeaders?: string | undefined;
+        responseSize?: number | undefined;
+        startTime?: string | undefined;
+        statusCode?: string | undefined;
+        statusMessage?: string | undefined;
+    }[] | undefined;
+    empty?: boolean | undefined;
+    first?: boolean | undefined;
+    last?: boolean | undefined;
+    number?: number | undefined;
+    numberOfElements?: number | undefined;
+    pageable?: {
+        offset?: number | undefined;
+        pageNumber?: number | undefined;
+        pageSize?: number | undefined;
+        paged?: boolean | undefined;
+        sort?: {
+            empty?: boolean | undefined;
+            sorted?: boolean | undefined;
+            unsorted?: boolean | undefined;
+        } | undefined;
+        unpaged?: boolean | undefined;
+    } | undefined;
+    size?: number | undefined;
+    sort?: {
+        empty?: boolean | undefined;
+        sorted?: boolean | undefined;
+        unsorted?: boolean | undefined;
+    } | undefined;
+    totalElements?: number | undefined;
+    totalPages?: number | undefined;
+}>;
+export declare const getSingleLogMessageLoader: (client: ApiClient) => ({ params }: LoaderFunctionArgs) => Promise<unknown>;

package/dist/types/routes/message-sending/MessageSendingRoute.d.ts

@@ -0,0 +1,2 @@
+declare const MessageSendingRoute: () => import("react").JSX.Element;
+export default MessageSendingRoute;

package/dist/types/routes/message-sending/SingleMessageRoute.d.ts

@@ -0,0 +1,2 @@
+declare const SingleMessageRoute: () => import("react").JSX.Element;
+export default SingleMessageRoute;

package/dist/types/routes/message-sending/api.d.ts

@@ -0,0 +1,92 @@
+import { ApiClient } from '../../client';
+import { paths } from '../../types/openapiTypes';
+export type MessageQuery = paths["/message"]["get"]["parameters"]["query"];
+export declare const fetchMessages: (query: MessageQuery, client: ApiClient) => Promise<{
+    content?: {
+        creationTime?: string | undefined;
+        failCount?: number | undefined;
+        id?: number | undefined;
+        lastUpdatedTime?: string | undefined;
+        messageChainId?: number | undefined;
+        messageGroupId?: string | undefined;
+        messageTargetConfig?: {
+            filters?: string | undefined;
+            id?: number | undefined;
+            maxConcurrency?: number | undefined;
+            messageType?: string | undefined;
+            properties?: {
+                [x: string]: string;
+            } | undefined;
+            retryDelayMs?: number | undefined;
+            retryLimit?: number | undefined;
+            state?: "ENABLED" | "LOG_ONLY" | "PAUSED" | "DISABLED" | undefined;
+            targetSystem?: string | undefined;
+            throttling?: string | undefined;
+            uri?: string | undefined;
+        } | undefined;
+        messageType?: string | undefined;
+        metadata?: {
+            [x: string]: string;
+        } | undefined;
+        priority?: number | undefined;
+        state?: "DELAYED" | "PENDING" | "SENDING" | "SENT" | "FAILED" | "DISABLED" | undefined;
+        targetSystem?: string | undefined;
+        targetUri?: string | undefined;
+    }[] | undefined;
+    empty?: boolean | undefined;
+    first?: boolean | undefined;
+    last?: boolean | undefined;
+    number?: number | undefined;
+    numberOfElements?: number | undefined;
+    pageable?: {
+        offset?: number | undefined;
+        pageNumber?: number | undefined;
+        pageSize?: number | undefined;
+        paged?: boolean | undefined;
+        sort?: {
+            empty?: boolean | undefined;
+            sorted?: boolean | undefined;
+            unsorted?: boolean | undefined;
+        } | undefined;
+        unpaged?: boolean | undefined;
+    } | undefined;
+    size?: number | undefined;
+    sort?: {
+        empty?: boolean | undefined;
+        sorted?: boolean | undefined;
+        unsorted?: boolean | undefined;
+    } | undefined;
+    totalElements?: number | undefined;
+    totalPages?: number | undefined;
+}>;
+export declare const fetchMessageById: (id: number, client: ApiClient) => Promise<{
+    creationTime?: string | undefined;
+    failCount?: number | undefined;
+    id?: number | undefined;
+    lastUpdatedTime?: string | undefined;
+    messageChainId?: number | undefined;
+    messageGroupId?: string | undefined;
+    messageTargetConfig?: {
+        filters?: string | undefined;
+        id?: number | undefined;
+        maxConcurrency?: number | undefined;
+        messageType?: string | undefined;
+        properties?: {
+            [x: string]: string;
+        } | undefined;
+        retryDelayMs?: number | undefined;
+        retryLimit?: number | undefined;
+        state?: "ENABLED" | "LOG_ONLY" | "PAUSED" | "DISABLED" | undefined;
+        targetSystem?: string | undefined;
+        throttling?: string | undefined;
+        uri?: string | undefined;
+    } | undefined;
+    messageType?: string | undefined;
+    metadata?: {
+        [x: string]: string;
+    } | undefined;
+    priority?: number | undefined;
+    state?: "DELAYED" | "PENDING" | "SENDING" | "SENT" | "FAILED" | "DISABLED" | undefined;
+    targetSystem?: string | undefined;
+    targetUri?: string | undefined;
+}>;

package/dist/types/routes/message-sending/index.d.ts

@@ -0,0 +1,4 @@
+export { getMessageListLoader, getSingleMessageLoader } from './loader';
+export { default as MessageSendingRoute } from './MessageSendingRoute';
+export { default as SingleMessageRoute } from './SingleMessageRoute';
+export { fetchMessages, fetchMessageById, type MessageQuery } from './api';

package/dist/types/routes/message-sending/loader.d.ts

@@ -0,0 +1,34 @@
+import { LoaderFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+export declare const getSingleMessageLoader: (client: ApiClient) => ({ params }: LoaderFunctionArgs) => Promise<{
+    creationTime?: string | undefined;
+    failCount?: number | undefined;
+    id?: number | undefined;
+    lastUpdatedTime?: string | undefined;
+    messageChainId?: number | undefined;
+    messageGroupId?: string | undefined;
+    messageTargetConfig?: {
+        filters?: string | undefined;
+        id?: number | undefined;
+        maxConcurrency?: number | undefined;
+        messageType?: string | undefined;
+        properties?: {
+            [x: string]: string;
+        } | undefined;
+        retryDelayMs?: number | undefined;
+        retryLimit?: number | undefined;
+        state?: "ENABLED" | "LOG_ONLY" | "PAUSED" | "DISABLED" | undefined;
+        targetSystem?: string | undefined;
+        throttling?: string | undefined;
+        uri?: string | undefined;
+    } | undefined;
+    messageType?: string | undefined;
+    metadata?: {
+        [x: string]: string;
+    } | undefined;
+    priority?: number | undefined;
+    state?: "DELAYED" | "PENDING" | "SENDING" | "SENT" | "FAILED" | "DISABLED" | undefined;
+    targetSystem?: string | undefined;
+    targetUri?: string | undefined;
+}>;
+export declare const getMessageListLoader: (client: ApiClient) => ({ request }: LoaderFunctionArgs) => Promise<unknown>;

package/dist/types/{admin-components/src/routes → routes}/message-sending/types.d.ts

@@ -1,5 +1,7 @@
 import { PagedResponse } from '../../common/types';
-export type MessageStatus = "DELAYED" | "PENDING" | "SENDING" | "SENT" | "FAILED" | "DISABLED";
+import { components } from '../../types/openapiTypes';
+export type MessageStatus = NonNullable<components["schemas"]["MessageLite"]["state"]>;
+export declare const messageStatuses: readonly ["DELAYED", "PENDING", "SENDING", "SENT", "FAILED", "DISABLED"];
 export type MessageData = {
     creationTime: string;
     failCount: number;
@@ -15,7 +17,7 @@ export type MessageData = {
     targetSystem: string;
     targetUri: string;
 };
-export type MessageTargetConfigStatus = "ENABLED" | "LOG_ONLY" | "PAUSED" | "DISABLED";
+export type MessageTargetConfigStatus = NonNullable<components["schemas"]["MessageTargetConfig"]["state"]>;
 export type MessageTargetConfig = {
     filters: string | null;
     id: number;

package/dist/types/routes/message-targets/MessageTargetFormRoute.d.ts

@@ -0,0 +1,2 @@
+declare const MessageTargetFormRoute: () => import("react").JSX.Element;
+export default MessageTargetFormRoute;

package/dist/types/routes/message-targets/MessageTargetsRoute.d.ts

@@ -0,0 +1,2 @@
+declare const MessageTargetsRoute: () => import("react").JSX.Element;
+export default MessageTargetsRoute;

package/dist/types/routes/message-targets/action.d.ts

@@ -0,0 +1,8 @@
+import { ActionFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+export type MessageTargetActionResult = {
+    status: number;
+    message: string;
+};
+export declare const getMessageTargetAction: (client: ApiClient) => ({ request }: ActionFunctionArgs) => Promise<MessageTargetActionResult>;
+export type MessageTargetFormAction = ReturnType<typeof getMessageTargetAction>;

package/dist/types/routes/message-targets/api.d.ts

@@ -0,0 +1,12 @@
+import { ApiClient } from '../../client';
+import { components } from '../../types/openapiTypes';
+export type MessageTargetConfig = components["schemas"]["MessageTargetConfig"];
+export type MessageTargetConfigRequestModel = components["schemas"]["MessageTargetConfigRequestModel"];
+export type MessageTargetConfigHistory = components["schemas"]["MessageTargetConfigHistory"];
+export type MessageTargetWithHistory = components["schemas"]["TargetWithHistory"];
+export declare const messageTargetStates: readonly ["ENABLED", "LOG_ONLY", "PAUSED", "DISABLED"];
+export declare const fetchMessageTargets: (client: ApiClient) => Promise<MessageTargetWithHistory[]>;
+export declare const fetchMessageTargetById: (id: number, client: ApiClient) => Promise<MessageTargetConfig>;
+export declare const createMessageTarget: (messageTarget: MessageTargetConfigRequestModel, client: ApiClient) => Promise<number>;
+export declare const updateMessageTarget: (id: number, messageTarget: MessageTargetConfigRequestModel, client: ApiClient) => Promise<number>;
+export declare const deleteMessageTarget: (id: number, client: ApiClient) => Promise<number>;

package/dist/types/routes/message-targets/index.d.ts

@@ -0,0 +1,5 @@
+export { default as MessageTargetFormRoute } from './MessageTargetFormRoute';
+export { default as MessageTargetsRoute } from './MessageTargetsRoute';
+export { getMessageTargetAction, type MessageTargetActionResult } from './action';
+export { createMessageTarget, deleteMessageTarget, fetchMessageTargetById, fetchMessageTargets, updateMessageTarget, type MessageTargetConfig, type MessageTargetConfigHistory, type MessageTargetConfigRequestModel, type MessageTargetWithHistory, } from './api';
+export { getInitialMessageTarget, getMessageTargetFormLoader, getMessageTargetsLoader, type MessageTargetFormLoaderData, } from './loader';

package/dist/types/routes/message-targets/loader.d.ts

@@ -0,0 +1,15 @@
+import { LoaderFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+import { MessageTargetConfig, MessageTargetConfigHistory } from './api';
+export type MessageTargetFormLoaderData = {
+    target: MessageTargetConfig;
+    history: MessageTargetConfigHistory[];
+};
+export declare const getInitialMessageTarget: () => MessageTargetConfig;
+export declare const getMessageTargetsLoader: (client: ApiClient) => () => Promise<{
+    history?: import('../../client').components["schemas"]["MessageTargetConfigHistory"][];
+    target?: import('../../client').components["schemas"]["MessageTargetConfig"];
+}[]>;
+export type MessageTargetsLoader = ReturnType<typeof getMessageTargetsLoader>;
+export declare const getMessageTargetFormLoader: (client: ApiClient) => ({ params }: LoaderFunctionArgs) => Promise<MessageTargetFormLoaderData>;
+export type MessageTargetFormLoader = ReturnType<typeof getMessageTargetFormLoader>;

package/dist/types/routes/scheduled-tasks/ScheduledTaskFormRoute.d.ts

@@ -0,0 +1,2 @@
+declare const ScheduledTaskFormRoute: () => import("react").JSX.Element;
+export default ScheduledTaskFormRoute;

package/dist/types/routes/scheduled-tasks/ScheduledTasksRoute.d.ts

@@ -0,0 +1,2 @@
+declare const ScheduledTasksRoute: () => import("react").JSX.Element;
+export default ScheduledTasksRoute;

package/dist/types/routes/scheduled-tasks/action.d.ts

@@ -0,0 +1,21 @@
+import { ActionFunctionArgs } from 'react-router';
+import { paths } from '../../types/openapiTypes';
+import { ApiClient } from '../../client';
+export type ScheduledTaskFormActionResult = {
+    status: number;
+    message: string;
+};
+export declare const getScheduledTaskFormAction: (client: ApiClient) => ({ request }: ActionFunctionArgs) => Promise<ScheduledTaskFormActionResult>;
+export type ScheduledTaskFormAction = ReturnType<typeof getScheduledTaskFormAction>;
+type ListActionType = "trigger" | "updateState";
+export interface ListActionPayload {
+    type: ListActionType;
+    id?: number;
+    state?: NonNullable<NonNullable<paths["/schedule/{id}/state/{state}"]["post"]>["parameters"]>["path"]["state"];
+}
+export declare const getScheduledTasksAction: (client: ApiClient) => ({ request }: ActionFunctionArgs) => Promise<{
+    status: number;
+    message: string;
+}>;
+export type ScheduledTasksAction = ReturnType<typeof getScheduledTasksAction>;
+export {};

package/dist/types/routes/scheduled-tasks/api.d.ts

@@ -0,0 +1,75 @@
+import { ApiClient } from '../../client';
+import { paths } from '../../types/openapiTypes';
+export type ScheduledTaskFilter = paths["/schedule"]["get"]["parameters"]["query"];
+export type ScheduledTask = paths["/schedule"]["post"]["requestBody"]["content"]["application/json"];
+type ScheduledTaskState = paths["/schedule/{id}/state/{state}"]["post"]["parameters"]["path"]["state"];
+export declare const fetchScheduledTasks: (query: ScheduledTaskFilter, client: ApiClient) => Promise<{
+    content?: {
+        args?: {
+            [x: string]: string;
+        } | undefined;
+        cronExpression: string;
+        id?: number | undefined;
+        lastFinishedTime?: number | undefined;
+        lastFiredTime?: number | undefined;
+        lastInitiator?: string | undefined;
+        missPolicy: "SKIP_ALL" | "RUN_ONCE" | "RUN_ALL";
+        name: string;
+        nextFireTime?: number | undefined;
+        priority: number;
+        running?: string | undefined;
+        state?: "WAITING" | "RUNNING" | "PAUSED" | undefined;
+        timeZone: string;
+        timeoutMs: number;
+        triggerable: string;
+    }[] | undefined;
+    empty?: boolean | undefined;
+    first?: boolean | undefined;
+    last?: boolean | undefined;
+    number?: number | undefined;
+    numberOfElements?: number | undefined;
+    pageable?: {
+        offset?: number | undefined;
+        pageNumber?: number | undefined;
+        pageSize?: number | undefined;
+        paged?: boolean | undefined;
+        sort?: {
+            empty?: boolean | undefined;
+            sorted?: boolean | undefined;
+            unsorted?: boolean | undefined;
+        } | undefined;
+        unpaged?: boolean | undefined;
+    } | undefined;
+    size?: number | undefined;
+    sort?: {
+        empty?: boolean | undefined;
+        sorted?: boolean | undefined;
+        unsorted?: boolean | undefined;
+    } | undefined;
+    totalElements?: number | undefined;
+    totalPages?: number | undefined;
+}>;
+export declare const fetchScheduledTaskById: (id: number, client: ApiClient) => Promise<{
+    args?: {
+        [x: string]: string;
+    } | undefined;
+    cronExpression: string;
+    id?: number | undefined;
+    lastFinishedTime?: number | undefined;
+    lastFiredTime?: number | undefined;
+    lastInitiator?: string | undefined;
+    missPolicy: "SKIP_ALL" | "RUN_ONCE" | "RUN_ALL";
+    name: string;
+    nextFireTime?: number | undefined;
+    priority: number;
+    running?: string | undefined;
+    state?: "WAITING" | "RUNNING" | "PAUSED" | undefined;
+    timeZone: string;
+    timeoutMs: number;
+    triggerable: string;
+}>;
+export declare const saveScheduledTask: (task: ScheduledTask, client: ApiClient) => Promise<number>;
+export declare const deleteScheduledTask: (id: number, client: ApiClient) => Promise<number>;
+export declare const runScheduledTask: (id: number, client: ApiClient) => Promise<number>;
+export declare const updateScheduledTaskState: (id: number, state: ScheduledTaskState, client: ApiClient) => Promise<number>;
+export {};

package/dist/types/routes/scheduled-tasks/index.d.ts

@@ -0,0 +1,5 @@
+export { getScheduledTaskFormAction, getScheduledTasksAction } from './action';
+export { getScheduledTasksLoader, getSingleTaskLoader } from './loader';
+export { default as ScheduledTaskFormRoute } from './ScheduledTaskFormRoute';
+export { default as ScheduledTasksRoute } from './ScheduledTasksRoute';
+export { fetchScheduledTasks, fetchScheduledTaskById, saveScheduledTask, deleteScheduledTask, runScheduledTask, updateScheduledTaskState, type ScheduledTaskFilter, type ScheduledTask, } from './api';

package/dist/types/routes/scheduled-tasks/loader.d.ts

@@ -0,0 +1,57 @@
+import { LoaderFunctionArgs } from 'react-router';
+import { ScheduledTask } from './api';
+import { ApiClient } from '../../client';
+import { components } from '../../types/openapiTypes';
+export type ScheduledTaskFormLoaderData = {
+    task: ScheduledTask;
+    triggerables: Record<string, components["schemas"]["ArgObject"][]>;
+};
+export declare const getSingleTaskLoader: (client: ApiClient) => ({ params }: LoaderFunctionArgs) => Promise<ScheduledTaskFormLoaderData>;
+export type SingleScheduledTaskLoader = ReturnType<typeof getSingleTaskLoader>;
+export declare const getScheduledTasksLoader: (client: ApiClient) => ({ request }: LoaderFunctionArgs) => Promise<{
+    content?: {
+        args?: {
+            [x: string]: string;
+        } | undefined;
+        cronExpression: string;
+        id?: number | undefined;
+        lastFinishedTime?: number | undefined;
+        lastFiredTime?: number | undefined;
+        lastInitiator?: string | undefined;
+        missPolicy: "SKIP_ALL" | "RUN_ONCE" | "RUN_ALL";
+        name: string;
+        nextFireTime?: number | undefined;
+        priority: number;
+        running?: string | undefined;
+        state?: "WAITING" | "RUNNING" | "PAUSED" | undefined;
+        timeZone: string;
+        timeoutMs: number;
+        triggerable: string;
+    }[] | undefined;
+    empty?: boolean | undefined;
+    first?: boolean | undefined;
+    last?: boolean | undefined;
+    number?: number | undefined;
+    numberOfElements?: number | undefined;
+    pageable?: {
+        offset?: number | undefined;
+        pageNumber?: number | undefined;
+        pageSize?: number | undefined;
+        paged?: boolean | undefined;
+        sort?: {
+            empty?: boolean | undefined;
+            sorted?: boolean | undefined;
+            unsorted?: boolean | undefined;
+        } | undefined;
+        unpaged?: boolean | undefined;
+    } | undefined;
+    size?: number | undefined;
+    sort?: {
+        empty?: boolean | undefined;
+        sorted?: boolean | undefined;
+        unsorted?: boolean | undefined;
+    } | undefined;
+    totalElements?: number | undefined;
+    totalPages?: number | undefined;
+}>;
+export type ScheduledTasksLoader = ReturnType<typeof getScheduledTasksLoader>;

package/dist/types/routes/scheduled-tasks/parseScheduledTask.d.ts

@@ -0,0 +1,15 @@
+import { ScheduledTask } from './api';
+export type ScheduledTaskFormErrors = Partial<Record<keyof ScheduledTask | "args", string>>;
+export type ScheduledTaskState = NonNullable<ScheduledTask["state"]>;
+export type ScheduledTaskMissPolicy = ScheduledTask["missPolicy"];
+export declare const scheduledTaskStates: readonly ["WAITING", "RUNNING", "PAUSED"];
+export declare const missPolicies: readonly ["SKIP_ALL", "RUN_ONCE", "RUN_ALL"];
+export declare const isScheduledTaskState: (value: string) => value is ScheduledTaskState;
+export declare const isMissPolicy: (value: string) => value is ScheduledTaskMissPolicy;
+export declare const parseScheduledTask: (task: ScheduledTask, argsText: string) => {
+    ok: true;
+    value: ScheduledTask;
+} | {
+    ok: false;
+    errors: ScheduledTaskFormErrors;
+};

package/dist/types/routes/triggerables/TriggerablesRoute.d.ts

@@ -0,0 +1,2 @@
+declare const TriggerablesRoute: () => import("react").JSX.Element;
+export default TriggerablesRoute;

package/dist/types/routes/triggerables/action.d.ts

@@ -0,0 +1,6 @@
+import { ActionFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+export declare const getTriggerablesAction: (client: ApiClient) => ({ request }: ActionFunctionArgs) => Promise<{
+    status: number;
+    data: string;
+}>;

package/dist/types/routes/triggerables/api.d.ts

@@ -0,0 +1,33 @@
+import { ApiClient } from '../../client';
+import { paths } from '../../types/openapiTypes';
+type TriggerRequestParameters = paths["/trigger/{name}/async"]["post"]["parameters"];
+type TriggerParams = TriggerRequestParameters["query"]["parameters"];
+export declare const fetchTriggerables: (client: ApiClient) => Promise<{
+    [x: string]: {
+        name?: string | undefined;
+        required?: boolean | undefined;
+        type?: string | undefined;
+    }[];
+}>;
+export declare const fetchActiveTaskStatuses: (client: ApiClient) => Promise<{
+    appServer?: string | undefined;
+    appVersion?: string | undefined;
+    description?: string | undefined;
+    durationMs?: number | undefined;
+    group?: string | undefined;
+    id?: number | undefined;
+    lastUpdated?: string | undefined;
+    message?: string | undefined;
+    metadata?: {
+        key?: string | undefined;
+        taskStatus?: /*elided*/ any | undefined;
+        value?: string | undefined;
+    }[] | undefined;
+    startTime?: string | undefined;
+    state?: "RUNNING" | "DONE" | "NOTHING_TO_DO" | "CANCELLED" | "CANCELLING" | "FAILED" | undefined;
+}[]>;
+export declare const triggerTriggerable: (triggerName: string, params: TriggerParams, client: ApiClient) => Promise<{
+    status: number;
+    data: string;
+}>;
+export {};

package/dist/types/routes/triggerables/index.d.ts

@@ -0,0 +1,4 @@
+export { getTriggerablesAction } from './action';
+export { getTriggerablesLoader } from './loader';
+export { default as TriggerablesRoute } from './TriggerablesRoute';
+export { fetchTriggerables, fetchActiveTaskStatuses, triggerTriggerable } from './api';

package/dist/types/routes/triggerables/loader.d.ts

@@ -0,0 +1,3 @@
+import { LoaderFunction } from 'react-router';
+import { ApiClient } from '../../client';
+export declare const getTriggerablesLoader: (client: ApiClient) => LoaderFunction;

package/dist/types/scheduled-tasks.d.ts

@@ -1,2 +1,2 @@
-export * from './admin-components/src/routes/scheduled-tasks/index'
+export * from './routes/scheduled-tasks/index.js'
 export {}

package/dist/types/table.d.ts

@@ -1,2 +1,2 @@
-export * from './admin-components/src/components/table/index'
+export * from './components/table/index.js'
 export {}

package/dist/types/triggerables.d.ts

@@ -1,2 +1,2 @@
-export * from './admin-components/src/routes/triggerables/index'
+export * from './routes/triggerables/index.js'
 export {}