@evolver-fi/evolver-basics-admin-components 1.0.0 → 8.2.2-alpha.3

package/dist/types/routes/jwt-tokens/api.d.ts

@@ -0,0 +1,41 @@
+import { ApiClient } from '../../client';
+import { paths } from '../../types/openapiTypes';
+type JwtListQuery = NonNullable<paths["/jwt"]["get"]>["parameters"]["query"];
+type JwtTokenRequest = NonNullable<paths["/jwt"]["post"]>["requestBody"]["content"]["application/json"];
+export type JwtTokensPageFilter = Pick<JwtListQuery, "page" | "size">;
+export declare const fetchJwtTokens: (filter: JwtTokensPageFilter, client: ApiClient) => Promise<{
+    content: {
+        id?: number | undefined;
+        jwtId?: string | undefined;
+        owner?: string | undefined;
+        permissionValidators?: unknown[] | 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 saveJwtToken: (token: JwtTokenRequest, client: ApiClient) => Promise<void>;
+export declare const deleteJwtToken: (tokenId: number, client: ApiClient) => Promise<void>;
+export {};

package/dist/types/routes/jwt-tokens/index.d.ts

@@ -0,0 +1,3 @@
+export { getJwtTokensLoader } from './loader';
+export { default as JwtTokensRoute } from './JwtTokensRoute';
+export { fetchJwtTokens, saveJwtToken, deleteJwtToken, type JwtTokensPageFilter } from './api';

package/dist/types/routes/jwt-tokens/loader.d.ts

@@ -0,0 +1,35 @@
+import { LoaderFunctionArgs } from 'react-router';
+import { ApiClient } from '../../client';
+export declare const getJwtTokensLoader: (client: ApiClient) => ({ request }: LoaderFunctionArgs) => Promise<{
+    content: {
+        id?: number | undefined;
+        jwtId?: string | undefined;
+        owner?: string | undefined;
+        permissionValidators?: unknown[] | 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;
+}>;

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

@@ -0,0 +1,6 @@
+declare const LogBodyLink: ({ size, id, type }: {
+    size: number;
+    id: number;
+    type: string;
+}) => number | import("react").JSX.Element;
+export default LogBodyLink;

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

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

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

@@ -0,0 +1,6 @@
+import { ApiClient } from '../../client';
+type SingleMessageRouteProps = {
+    client: ApiClient;
+};
+declare const SingleMessageRoute: ({ client }: SingleMessageRouteProps) => import("react").JSX.Element;
+export default SingleMessageRoute;

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-log/messageLogColumns.d.ts

@@ -0,0 +1,3 @@
+import { ColumnDefinitions } from '../../components/table/types';
+import { LogFilter, LogMessage } from './types';
+export declare const messageLogColumns: ColumnDefinitions<LogMessage, LogFilter>;

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

@@ -0,0 +1,37 @@
+import { PagedResponse } from '../../common/types';
+export type LogMessage = {
+    id: number;
+    address: string;
+    appServer: string;
+    appVersion: string;
+    durationMs: number;
+    messageChainId: number;
+    dataDirection: "OUTBOUND" | "INBOUND";
+    messageType: string;
+    protocol: string;
+    requestHeaders: string;
+    requestSize: number;
+    responseHeaders: string;
+    responseSize: number;
+    requestingSystem: string;
+    startTime: string;
+    statusCode: string;
+    statusMessage: string;
+    respondingSystem: string;
+    metadata: Record<string, string>;
+};
+export type LogMessageResponse = PagedResponse<LogMessage>;
+export interface LogFilter {
+    appVersion: string;
+    messageType: string;
+    protocol: string;
+    startTime: string;
+    durationMs: string;
+    statusCode: string;
+    messageChainId: string;
+    requestSize: string;
+    responseSize: string;
+    metadata: string;
+    requestingSystem: string;
+    respondingSystem: string;
+}

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/routes/message-sending/messageSendingColumns.d.ts

@@ -0,0 +1,3 @@
+import { ColumnDefinitions } from '../../components/table/types';
+import { MessageData, MessageFilter } from './types';
+export declare const messageSendingColumns: ColumnDefinitions<MessageData, MessageFilter>;

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

@@ -0,0 +1,43 @@
+import { PagedResponse } from '../../common/types';
+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;
+    id: number;
+    lastUpdatedTime: string;
+    messageChainId: number;
+    messageGroupId: string;
+    messageTargetConfig: MessageTargetConfig;
+    messageType: string;
+    metadata: Record<string, string>;
+    priority: number;
+    state: MessageStatus;
+    targetSystem: string;
+    targetUri: string;
+};
+export type MessageTargetConfigStatus = NonNullable<components["schemas"]["MessageTargetConfig"]["state"]>;
+export type MessageTargetConfig = {
+    filters: string | null;
+    id: number;
+    messageType: string;
+    properties: Record<string, string>;
+    retryDelayMs: number;
+    retryLimit: number;
+    state: MessageTargetConfigStatus;
+    targetSystem: string;
+    throttling: string | null;
+    uri: string;
+};
+export type MessageFilter = {
+    state: string;
+    messageChainId: string;
+    creationTime: string;
+    lastUpdatedTime: string;
+    failCount: string;
+    messageGroupId: string;
+    priority: string;
+    metadata: string;
+};
+export type MessageResponse = PagedResponse<MessageData>;

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';