unchained/mission-control
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add custom-fields

Browse Source
This commit is contained in:
Abhimanyu Saharan
2026-02-13 21:24:36 +05:30
parent b032e94ca1
commit 277bfcb33a
127 changed files with 11305 additions and 6643 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5321
frontend/src/api/generated/agent/agent.ts
View File

File diff suppressed because it is too large Load Diff

490
frontend/src/api/generated/agents/agents.ts
View File

@@ -364,6 +364,134 @@ export const useCreateAgentApiV1AgentsPost = <
queryClient,
);
};
/**
* Heartbeat an existing agent or create/provision one if needed.
* @summary Heartbeat Or Create Agent
*/
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 = {
data: AgentRead;
status: 200;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess =
heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 & {
headers: Headers;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError =
heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 & {
headers: Headers;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse =
| heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess
| heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError;
export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl = () => {
return `/api/v1/agents/heartbeat`;
};
export const heartbeatOrCreateAgentApiV1AgentsHeartbeatPost = async (
agentHeartbeatCreate: AgentHeartbeatCreate,
options?: RequestInit,
): Promise<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse> => {
return customFetch<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse>(
getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl(),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(agentHeartbeatCreate),
},
);
};
export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
TError,
{ data: AgentHeartbeatCreate },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
TError,
{ data: AgentHeartbeatCreate },
TContext
> => {
const mutationKey = ["heartbeatOrCreateAgentApiV1AgentsHeartbeatPost"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
{ data: AgentHeartbeatCreate }
> = (props) => {
const { data } = props ?? {};
return heartbeatOrCreateAgentApiV1AgentsHeartbeatPost(
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationResult =
NonNullable<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>
>;
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationBody =
AgentHeartbeatCreate;
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationError =
HTTPValidationError;
/**
* @summary Heartbeat Or Create Agent
*/
export const useHeartbeatOrCreateAgentApiV1AgentsHeartbeatPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
TError,
{ data: AgentHeartbeatCreate },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
TError,
{ data: AgentHeartbeatCreate },
TContext
> => {
return useMutation(
getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions(options),
queryClient,
);
};
/**
* Stream agent updates as SSE events.
* @summary Stream Agents
@@ -576,6 +704,123 @@ export function useStreamAgentsApiV1AgentsStreamGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* Delete an agent and clean related task state.
* @summary Delete Agent
*/
export type deleteAgentApiV1AgentsAgentIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess =
deleteAgentApiV1AgentsAgentIdDeleteResponse200 & {
headers: Headers;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponseError =
deleteAgentApiV1AgentsAgentIdDeleteResponse422 & {
headers: Headers;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponse =
| deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess
| deleteAgentApiV1AgentsAgentIdDeleteResponseError;
export const getDeleteAgentApiV1AgentsAgentIdDeleteUrl = (agentId: string) => {
return `/api/v1/agents/${agentId}`;
};
export const deleteAgentApiV1AgentsAgentIdDelete = async (
agentId: string,
options?: RequestInit,
): Promise<deleteAgentApiV1AgentsAgentIdDeleteResponse> => {
return customFetch<deleteAgentApiV1AgentsAgentIdDeleteResponse>(
getDeleteAgentApiV1AgentsAgentIdDeleteUrl(agentId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
> => {
const mutationKey = ["deleteAgentApiV1AgentsAgentIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
{ agentId: string }
> = (props) => {
const { agentId } = props ?? {};
return deleteAgentApiV1AgentsAgentIdDelete(agentId, requestOptions);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteAgentApiV1AgentsAgentIdDeleteMutationResult = NonNullable<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>
>;
export type DeleteAgentApiV1AgentsAgentIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Agent
*/
export const useDeleteAgentApiV1AgentsAgentIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
> => {
return useMutation(
getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* Get a single agent by id.
* @summary Get Agent
@@ -937,123 +1182,6 @@ export const useUpdateAgentApiV1AgentsAgentIdPatch = <
queryClient,
);
};
/**
* Delete an agent and clean related task state.
* @summary Delete Agent
*/
export type deleteAgentApiV1AgentsAgentIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess =
deleteAgentApiV1AgentsAgentIdDeleteResponse200 & {
headers: Headers;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponseError =
deleteAgentApiV1AgentsAgentIdDeleteResponse422 & {
headers: Headers;
};
export type deleteAgentApiV1AgentsAgentIdDeleteResponse =
| deleteAgentApiV1AgentsAgentIdDeleteResponseSuccess
| deleteAgentApiV1AgentsAgentIdDeleteResponseError;
export const getDeleteAgentApiV1AgentsAgentIdDeleteUrl = (agentId: string) => {
return `/api/v1/agents/${agentId}`;
};
export const deleteAgentApiV1AgentsAgentIdDelete = async (
agentId: string,
options?: RequestInit,
): Promise<deleteAgentApiV1AgentsAgentIdDeleteResponse> => {
return customFetch<deleteAgentApiV1AgentsAgentIdDeleteResponse>(
getDeleteAgentApiV1AgentsAgentIdDeleteUrl(agentId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
> => {
const mutationKey = ["deleteAgentApiV1AgentsAgentIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
{ agentId: string }
> = (props) => {
const { agentId } = props ?? {};
return deleteAgentApiV1AgentsAgentIdDelete(agentId, requestOptions);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteAgentApiV1AgentsAgentIdDeleteMutationResult = NonNullable<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>
>;
export type DeleteAgentApiV1AgentsAgentIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Agent
*/
export const useDeleteAgentApiV1AgentsAgentIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteAgentApiV1AgentsAgentIdDelete>>,
TError,
{ agentId: string },
TContext
> => {
return useMutation(
getDeleteAgentApiV1AgentsAgentIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* Record a heartbeat for a specific agent.
* @summary Heartbeat Agent
@@ -1182,131 +1310,3 @@ export const useHeartbeatAgentApiV1AgentsAgentIdHeartbeatPost = <
queryClient,
);
};
/**
* Heartbeat an existing agent or create/provision one if needed.
* @summary Heartbeat Or Create Agent
*/
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 = {
data: AgentRead;
status: 200;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess =
heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse200 & {
headers: Headers;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError =
heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse422 & {
headers: Headers;
};
export type heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse =
| heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseSuccess
| heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponseError;
export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl = () => {
return `/api/v1/agents/heartbeat`;
};
export const heartbeatOrCreateAgentApiV1AgentsHeartbeatPost = async (
agentHeartbeatCreate: AgentHeartbeatCreate,
options?: RequestInit,
): Promise<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse> => {
return customFetch<heartbeatOrCreateAgentApiV1AgentsHeartbeatPostResponse>(
getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostUrl(),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(agentHeartbeatCreate),
},
);
};
export const getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
TError,
{ data: AgentHeartbeatCreate },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
TError,
{ data: AgentHeartbeatCreate },
TContext
> => {
const mutationKey = ["heartbeatOrCreateAgentApiV1AgentsHeartbeatPost"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
{ data: AgentHeartbeatCreate }
> = (props) => {
const { data } = props ?? {};
return heartbeatOrCreateAgentApiV1AgentsHeartbeatPost(
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationResult =
NonNullable<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>
>;
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationBody =
AgentHeartbeatCreate;
export type HeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationError =
HTTPValidationError;
/**
* @summary Heartbeat Or Create Agent
*/
export const useHeartbeatOrCreateAgentApiV1AgentsHeartbeatPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>
>,
TError,
{ data: AgentHeartbeatCreate },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof heartbeatOrCreateAgentApiV1AgentsHeartbeatPost>>,
TError,
{ data: AgentHeartbeatCreate },
TContext
> => {
return useMutation(
getHeartbeatOrCreateAgentApiV1AgentsHeartbeatPostMutationOptions(options),
queryClient,
);
};

11
frontend/src/api/generated/board-group-memory/board-group-memory.ts
View File

@@ -801,7 +801,9 @@ export function useStreamBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryStreamGet<
}
/**
* List memory entries for the board's linked group.
* List shared memory for the board's linked group.
Use this for cross-board context and coordination signals.
* @summary List Board Group Memory For Board
*/
export type listBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryGetResponse200 =
@@ -1123,7 +1125,10 @@ export function useListBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryGet<
}
/**
* Create a group memory entry from a board context and notify recipients.
* Create shared group memory from a board context.
When tags/mentions indicate chat or broadcast intent, eligible agents in the
linked group are notified.
* @summary Create Board Group Memory For Board
*/
export type createBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryPostResponse200 =
@@ -1280,7 +1285,7 @@ export const useCreateBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryPost
);
};
/**
* Stream memory entries for the board's linked group.
* Stream linked-group memory via SSE for near-real-time coordination.
* @summary Stream Board Group Memory For Board
*/
export type streamBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryStreamGetResponse200 =

483
frontend/src/api/generated/board-groups/board-groups.ts
View File

@@ -369,6 +369,129 @@ export const useCreateBoardGroupApiV1BoardGroupsPost = <
queryClient,
);
};
/**
* Delete a board group.
* @summary Delete Board Group
*/
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess =
deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 & {
headers: Headers;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError =
deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 & {
headers: Headers;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse =
| deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess
| deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError;
export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl = (
groupId: string,
) => {
return `/api/v1/board-groups/${groupId}`;
};
export const deleteBoardGroupApiV1BoardGroupsGroupIdDelete = async (
groupId: string,
options?: RequestInit,
): Promise<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse> => {
return customFetch<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse>(
getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl(groupId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
> => {
const mutationKey = ["deleteBoardGroupApiV1BoardGroupsGroupIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
{ groupId: string }
> = (props) => {
const { groupId } = props ?? {};
return deleteBoardGroupApiV1BoardGroupsGroupIdDelete(
groupId,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationResult =
NonNullable<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>
>;
export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Board Group
*/
export const useDeleteBoardGroupApiV1BoardGroupsGroupIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
> => {
return useMutation(
getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* Get a board group by id.
* @summary Get Board Group
@@ -707,125 +830,161 @@ export const useUpdateBoardGroupApiV1BoardGroupsGroupIdPatch = <
);
};
/**
* Delete a board group.
* @summary Delete Board Group
* Apply heartbeat settings to agents in a board group.
* @summary Apply Board Group Heartbeat
*/
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 =
{
data: BoardGroupHeartbeatApplyResult;
status: 200;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 =
{
data: HTTPValidationError;
status: 422;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess =
deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse200 & {
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess =
applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 & {
headers: Headers;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError =
deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse422 & {
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError =
applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 & {
headers: Headers;
};
export type deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse =
| deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseSuccess
| deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponseError;
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse =
export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl = (
groupId: string,
) => {
return `/api/v1/board-groups/${groupId}`;
};
| applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess
| applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError;
export const deleteBoardGroupApiV1BoardGroupsGroupIdDelete = async (
groupId: string,
options?: RequestInit,
): Promise<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse> => {
return customFetch<deleteBoardGroupApiV1BoardGroupsGroupIdDeleteResponse>(
getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteUrl(groupId),
{
...options,
method: "DELETE",
},
);
};
export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl =
(groupId: string) => {
return `/api/v1/board-groups/${groupId}/heartbeat`;
};
export const getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
TError,
{ groupId: string },
TContext
> => {
const mutationKey = ["deleteBoardGroupApiV1BoardGroupsGroupIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
{ groupId: string }
> = (props) => {
const { groupId } = props ?? {};
return deleteBoardGroupApiV1BoardGroupsGroupIdDelete(
groupId,
requestOptions,
export const applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost =
async (
groupId: string,
boardGroupHeartbeatApply: BoardGroupHeartbeatApply,
options?: RequestInit,
): Promise<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse> => {
return customFetch<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse>(
getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl(
groupId,
),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardGroupHeartbeatApply),
},
);
};
return { mutationFn, ...mutationOptions };
};
export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
> => {
const mutationKey = [
"applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationResult =
const mutationFn: MutationFunction<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
{ groupId: string; data: BoardGroupHeartbeatApply }
> = (props) => {
const { groupId, data } = props ?? {};
return applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost(
groupId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationResult =
NonNullable<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>
>;
export type DeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationError =
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationBody =
BoardGroupHeartbeatApply;
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationError =
HTTPValidationError;
/**
* @summary Delete Board Group
* @summary Apply Board Group Heartbeat
*/
export const useDeleteBoardGroupApiV1BoardGroupsGroupIdDelete = <
export const useApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string },
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteBoardGroupApiV1BoardGroupsGroupIdDelete>>,
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string },
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
> => {
return useMutation(
getDeleteBoardGroupApiV1BoardGroupsGroupIdDeleteMutationOptions(options),
getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions(
options,
),
queryClient,
);
};
@@ -1131,163 +1290,3 @@ export function useGetBoardGroupSnapshotApiV1BoardGroupsGroupIdSnapshotGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* Apply heartbeat settings to agents in a board group.
* @summary Apply Board Group Heartbeat
*/
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 =
{
data: BoardGroupHeartbeatApplyResult;
status: 200;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 =
{
data: HTTPValidationError;
status: 422;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess =
applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse200 & {
headers: Headers;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError =
applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse422 & {
headers: Headers;
};
export type applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse =
| applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseSuccess
| applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponseError;
export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl =
(groupId: string) => {
return `/api/v1/board-groups/${groupId}/heartbeat`;
};
export const applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost =
async (
groupId: string,
boardGroupHeartbeatApply: BoardGroupHeartbeatApply,
options?: RequestInit,
): Promise<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse> => {
return customFetch<applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostResponse>(
getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostUrl(
groupId,
),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardGroupHeartbeatApply),
},
);
};
export const getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
> => {
const mutationKey = [
"applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
{ groupId: string; data: BoardGroupHeartbeatApply }
> = (props) => {
const { groupId, data } = props ?? {};
return applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost(
groupId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationResult =
NonNullable<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>
>;
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationBody =
BoardGroupHeartbeatApply;
export type ApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationError =
HTTPValidationError;
/**
* @summary Apply Board Group Heartbeat
*/
export const useApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<
ReturnType<
typeof applyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPost
>
>,
TError,
{ groupId: string; data: BoardGroupHeartbeatApply },
TContext
> => {
return useMutation(
getApplyBoardGroupHeartbeatApiV1BoardGroupsGroupIdHeartbeatPostMutationOptions(
options,
),
queryClient,
);
};

584
frontend/src/api/generated/board-onboarding/board-onboarding.ts
View File

@@ -274,298 +274,6 @@ export function useGetOnboardingApiV1BoardsBoardIdOnboardingGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* Start onboarding and send instructions to the gateway agent.
* @summary Start Onboarding
*/
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 = {
data: BoardOnboardingRead;
status: 200;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess =
startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 & {
headers: Headers;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError =
startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 & {
headers: Headers;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse =
| startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess
| startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError;
export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/onboarding/start`;
};
export const startOnboardingApiV1BoardsBoardIdOnboardingStartPost = async (
boardId: string,
boardOnboardingStart: BoardOnboardingStart,
options?: RequestInit,
): Promise<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse> => {
return customFetch<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse>(
getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl(boardId),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardOnboardingStart),
},
);
};
export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
> => {
const mutationKey = [
"startOnboardingApiV1BoardsBoardIdOnboardingStartPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
{ boardId: string; data: BoardOnboardingStart }
> = (props) => {
const { boardId, data } = props ?? {};
return startOnboardingApiV1BoardsBoardIdOnboardingStartPost(
boardId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationResult =
NonNullable<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>
>;
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationBody =
BoardOnboardingStart;
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationError =
HTTPValidationError;
/**
* @summary Start Onboarding
*/
export const useStartOnboardingApiV1BoardsBoardIdOnboardingStartPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
> => {
return useMutation(
getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions(
options,
),
queryClient,
);
};
/**
* Send a user onboarding answer to the gateway agent.
* @summary Answer Onboarding
*/
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 =
{
data: BoardOnboardingRead;
status: 200;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 =
{
data: HTTPValidationError;
status: 422;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess =
answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 & {
headers: Headers;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError =
answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 & {
headers: Headers;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse =
| answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess
| answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError;
export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/onboarding/answer`;
};
export const answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = async (
boardId: string,
boardOnboardingAnswer: BoardOnboardingAnswer,
options?: RequestInit,
): Promise<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse> => {
return customFetch<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse>(
getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl(boardId),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardOnboardingAnswer),
},
);
};
export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
> => {
const mutationKey = [
"answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
{ boardId: string; data: BoardOnboardingAnswer }
> = (props) => {
const { boardId, data } = props ?? {};
return answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost(
boardId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationResult =
NonNullable<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>
>;
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationBody =
BoardOnboardingAnswer;
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationError =
HTTPValidationError;
/**
* @summary Answer Onboarding
*/
export const useAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
> => {
return useMutation(
getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions(
options,
),
queryClient,
);
};
/**
* Store onboarding updates submitted by the gateway agent.
* @summary Agent Onboarding Update
@@ -741,6 +449,156 @@ export const useAgentOnboardingUpdateApiV1BoardsBoardIdOnboardingAgentPost = <
queryClient,
);
};
/**
* Send a user onboarding answer to the gateway agent.
* @summary Answer Onboarding
*/
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 =
{
data: BoardOnboardingRead;
status: 200;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 =
{
data: HTTPValidationError;
status: 422;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess =
answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse200 & {
headers: Headers;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError =
answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse422 & {
headers: Headers;
};
export type answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse =
| answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseSuccess
| answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponseError;
export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/onboarding/answer`;
};
export const answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = async (
boardId: string,
boardOnboardingAnswer: BoardOnboardingAnswer,
options?: RequestInit,
): Promise<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse> => {
return customFetch<answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostResponse>(
getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostUrl(boardId),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardOnboardingAnswer),
},
);
};
export const getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
> => {
const mutationKey = [
"answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
{ boardId: string; data: BoardOnboardingAnswer }
> = (props) => {
const { boardId, data } = props ?? {};
return answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost(
boardId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationResult =
NonNullable<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>
>;
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationBody =
BoardOnboardingAnswer;
export type AnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationError =
HTTPValidationError;
/**
* @summary Answer Onboarding
*/
export const useAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<
typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost
>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<
ReturnType<typeof answerOnboardingApiV1BoardsBoardIdOnboardingAnswerPost>
>,
TError,
{ boardId: string; data: BoardOnboardingAnswer },
TContext
> => {
return useMutation(
getAnswerOnboardingApiV1BoardsBoardIdOnboardingAnswerPostMutationOptions(
options,
),
queryClient,
);
};
/**
* Confirm onboarding results and provision the board lead agent.
* @summary Confirm Onboarding
@@ -895,3 +753,145 @@ export const useConfirmOnboardingApiV1BoardsBoardIdOnboardingConfirmPost = <
queryClient,
);
};
/**
* Start onboarding and send instructions to the gateway agent.
* @summary Start Onboarding
*/
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 = {
data: BoardOnboardingRead;
status: 200;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess =
startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse200 & {
headers: Headers;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError =
startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse422 & {
headers: Headers;
};
export type startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse =
| startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseSuccess
| startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponseError;
export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/onboarding/start`;
};
export const startOnboardingApiV1BoardsBoardIdOnboardingStartPost = async (
boardId: string,
boardOnboardingStart: BoardOnboardingStart,
options?: RequestInit,
): Promise<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse> => {
return customFetch<startOnboardingApiV1BoardsBoardIdOnboardingStartPostResponse>(
getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostUrl(boardId),
{
...options,
method: "POST",
headers: { "Content-Type": "application/json", ...options?.headers },
body: JSON.stringify(boardOnboardingStart),
},
);
};
export const getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions =
<TError = HTTPValidationError, TContext = unknown>(options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
> => {
const mutationKey = [
"startOnboardingApiV1BoardsBoardIdOnboardingStartPost",
];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
{ boardId: string; data: BoardOnboardingStart }
> = (props) => {
const { boardId, data } = props ?? {};
return startOnboardingApiV1BoardsBoardIdOnboardingStartPost(
boardId,
data,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationResult =
NonNullable<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>
>;
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationBody =
BoardOnboardingStart;
export type StartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationError =
HTTPValidationError;
/**
* @summary Start Onboarding
*/
export const useStartOnboardingApiV1BoardsBoardIdOnboardingStartPost = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<
ReturnType<typeof startOnboardingApiV1BoardsBoardIdOnboardingStartPost>
>,
TError,
{ boardId: string; data: BoardOnboardingStart },
TContext
> => {
return useMutation(
getStartOnboardingApiV1BoardsBoardIdOnboardingStartPostMutationOptions(
options,
),
queryClient,
);
};

714
frontend/src/api/generated/boards/boards.ts
View File

@@ -363,6 +363,123 @@ export const useCreateBoardApiV1BoardsPost = <
queryClient,
);
};
/**
* Delete a board and all dependent records.
* @summary Delete Board
*/
export type deleteBoardApiV1BoardsBoardIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess =
deleteBoardApiV1BoardsBoardIdDeleteResponse200 & {
headers: Headers;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponseError =
deleteBoardApiV1BoardsBoardIdDeleteResponse422 & {
headers: Headers;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponse =
| deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess
| deleteBoardApiV1BoardsBoardIdDeleteResponseError;
export const getDeleteBoardApiV1BoardsBoardIdDeleteUrl = (boardId: string) => {
return `/api/v1/boards/${boardId}`;
};
export const deleteBoardApiV1BoardsBoardIdDelete = async (
boardId: string,
options?: RequestInit,
): Promise<deleteBoardApiV1BoardsBoardIdDeleteResponse> => {
return customFetch<deleteBoardApiV1BoardsBoardIdDeleteResponse>(
getDeleteBoardApiV1BoardsBoardIdDeleteUrl(boardId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
> => {
const mutationKey = ["deleteBoardApiV1BoardsBoardIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
{ boardId: string }
> = (props) => {
const { boardId } = props ?? {};
return deleteBoardApiV1BoardsBoardIdDelete(boardId, requestOptions);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteBoardApiV1BoardsBoardIdDeleteMutationResult = NonNullable<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>
>;
export type DeleteBoardApiV1BoardsBoardIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Board
*/
export const useDeleteBoardApiV1BoardsBoardIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
> => {
return useMutation(
getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* Get a board by id.
* @summary Get Board
@@ -683,364 +800,10 @@ export const useUpdateBoardApiV1BoardsBoardIdPatch = <
queryClient,
);
};
/**
* Delete a board and all dependent records.
* @summary Delete Board
*/
export type deleteBoardApiV1BoardsBoardIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess =
deleteBoardApiV1BoardsBoardIdDeleteResponse200 & {
headers: Headers;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponseError =
deleteBoardApiV1BoardsBoardIdDeleteResponse422 & {
headers: Headers;
};
export type deleteBoardApiV1BoardsBoardIdDeleteResponse =
| deleteBoardApiV1BoardsBoardIdDeleteResponseSuccess
| deleteBoardApiV1BoardsBoardIdDeleteResponseError;
export const getDeleteBoardApiV1BoardsBoardIdDeleteUrl = (boardId: string) => {
return `/api/v1/boards/${boardId}`;
};
export const deleteBoardApiV1BoardsBoardIdDelete = async (
boardId: string,
options?: RequestInit,
): Promise<deleteBoardApiV1BoardsBoardIdDeleteResponse> => {
return customFetch<deleteBoardApiV1BoardsBoardIdDeleteResponse>(
getDeleteBoardApiV1BoardsBoardIdDeleteUrl(boardId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
> => {
const mutationKey = ["deleteBoardApiV1BoardsBoardIdDelete"];
const { mutation: mutationOptions, request: requestOptions } = options
? options.mutation &&
"mutationKey" in options.mutation &&
options.mutation.mutationKey
? options
: { ...options, mutation: { ...options.mutation, mutationKey } }
: { mutation: { mutationKey }, request: undefined };
const mutationFn: MutationFunction<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
{ boardId: string }
> = (props) => {
const { boardId } = props ?? {};
return deleteBoardApiV1BoardsBoardIdDelete(boardId, requestOptions);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteBoardApiV1BoardsBoardIdDeleteMutationResult = NonNullable<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>
>;
export type DeleteBoardApiV1BoardsBoardIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Board
*/
export const useDeleteBoardApiV1BoardsBoardIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteBoardApiV1BoardsBoardIdDelete>>,
TError,
{ boardId: string },
TContext
> => {
return useMutation(
getDeleteBoardApiV1BoardsBoardIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* Get a board snapshot view model.
* @summary Get Board Snapshot
*/
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 = {
data: BoardSnapshot;
status: 200;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess =
getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 & {
headers: Headers;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError =
getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 & {
headers: Headers;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse =
| getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess
| getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError;
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/snapshot`;
};
export const getBoardSnapshotApiV1BoardsBoardIdSnapshotGet = async (
boardId: string,
options?: RequestInit,
): Promise<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse> => {
return customFetch<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse>(
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl(boardId),
{
...options,
method: "GET",
},
);
};
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey = (
boardId: string,
) => {
return [`/api/v1/boards/${boardId}/snapshot`] as const;
};
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions = <
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
) => {
const { query: queryOptions, request: requestOptions } = options ?? {};
const queryKey =
queryOptions?.queryKey ??
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey(boardId);
const queryFn: QueryFunction<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
> = ({ signal }) =>
getBoardSnapshotApiV1BoardsBoardIdSnapshotGet(boardId, {
signal,
...requestOptions,
});
return {
queryKey,
queryFn,
enabled: !!boardId,
...queryOptions,
} as UseQueryOptions<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>,
TError,
TData
> & { queryKey: DataTag<QueryKey, TData, TError> };
};
export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryResult =
NonNullable<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
>;
export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryError =
HTTPValidationError;
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options: {
query: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
> &
Pick<
DefinedInitialDataOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
> &
Pick<
UndefinedInitialDataOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
/**
* @summary Get Board Snapshot
*/
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
} {
const queryOptions =
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions(
boardId,
options,
);
const query = useQuery(queryOptions, queryClient) as UseQueryResult<
TData,
TError
> & { queryKey: DataTag<QueryKey, TData, TError> };
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* Get a grouped snapshot across related boards.
Returns high-signal cross-board status for dependency and overlap checks.
* @summary Get Board Group Snapshot
*/
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse200 =
@@ -1341,3 +1104,242 @@ export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* Get a board snapshot view model.
* @summary Get Board Snapshot
*/
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 = {
data: BoardSnapshot;
status: 200;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess =
getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse200 & {
headers: Headers;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError =
getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse422 & {
headers: Headers;
};
export type getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse =
| getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseSuccess
| getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponseError;
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl = (
boardId: string,
) => {
return `/api/v1/boards/${boardId}/snapshot`;
};
export const getBoardSnapshotApiV1BoardsBoardIdSnapshotGet = async (
boardId: string,
options?: RequestInit,
): Promise<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse> => {
return customFetch<getBoardSnapshotApiV1BoardsBoardIdSnapshotGetResponse>(
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetUrl(boardId),
{
...options,
method: "GET",
},
);
};
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey = (
boardId: string,
) => {
return [`/api/v1/boards/${boardId}/snapshot`] as const;
};
export const getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions = <
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
) => {
const { query: queryOptions, request: requestOptions } = options ?? {};
const queryKey =
queryOptions?.queryKey ??
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryKey(boardId);
const queryFn: QueryFunction<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
> = ({ signal }) =>
getBoardSnapshotApiV1BoardsBoardIdSnapshotGet(boardId, {
signal,
...requestOptions,
});
return {
queryKey,
queryFn,
enabled: !!boardId,
...queryOptions,
} as UseQueryOptions<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>,
TError,
TData
> & { queryKey: DataTag<QueryKey, TData, TError> };
};
export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryResult =
NonNullable<
Awaited<ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>>
>;
export type GetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryError =
HTTPValidationError;
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options: {
query: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
> &
Pick<
DefinedInitialDataOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
> &
Pick<
UndefinedInitialDataOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
/**
* @summary Get Board Snapshot
*/
export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<typeof getBoardSnapshotApiV1BoardsBoardIdSnapshotGet>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
} {
const queryOptions =
getGetBoardSnapshotApiV1BoardsBoardIdSnapshotGetQueryOptions(
boardId,
options,
);
const query = useQuery(queryOptions, queryClient) as UseQueryResult<
TData,
TError
> & { queryKey: DataTag<QueryKey, TData, TError> };
return { ...query, queryKey: queryOptions.queryKey };
}

910
frontend/src/api/generated/gateways/gateways.ts
View File

File diff suppressed because it is too large Load Diff

8
frontend/src/api/generated/model/activityEventRead.ts
View File

@@ -9,10 +9,10 @@
* Serialized activity event payload returned by activity endpoints.
*/
export interface ActivityEventRead {
id: string;
event_type: string;
message: string | null;
agent_id: string | null;
task_id: string | null;
created_at: string;
event_type: string;
id: string;
message: string | null;
task_id: string | null;
}

10
frontend/src/api/generated/model/activityTaskCommentFeedItemRead.ts
View File

@@ -9,14 +9,14 @@
* Denormalized task-comment feed item enriched with task and board fields.
*/
export interface ActivityTaskCommentFeedItemRead {
id: string;
created_at: string;
message: string | null;
agent_id: string | null;
agent_name?: string | null;
agent_role?: string | null;
task_id: string;
task_title: string;
board_id: string;
board_name: string;
created_at: string;
id: string;
message: string | null;
task_id: string;
task_title: string;
}

6
frontend/src/api/generated/model/agentCreate.ts
View File

@@ -12,11 +12,11 @@ import type { AgentCreateIdentityProfile } from "./agentCreateIdentityProfile";
*/
export interface AgentCreate {
board_id?: string | null;
/** @minLength 1 */
name: string;
status?: string;
heartbeat_config?: AgentCreateHeartbeatConfig;
identity_profile?: AgentCreateIdentityProfile;
identity_template?: string | null;
/** @minLength 1 */
name: string;
soul_template?: string | null;
status?: string;
}

4
frontend/src/api/generated/model/agentHeartbeatCreate.ts
View File

@@ -9,8 +9,8 @@
* Heartbeat payload used to create an agent lazily.
*/
export interface AgentHeartbeatCreate {
status?: string | null;
board_id?: string | null;
/** @minLength 1 */
name: string;
board_id?: string | null;
status?: string | null;
}

16
frontend/src/api/generated/model/agentRead.ts
View File

@@ -12,19 +12,19 @@ import type { AgentReadIdentityProfile } from "./agentReadIdentityProfile";
*/
export interface AgentRead {
board_id?: string | null;
/** @minLength 1 */
name: string;
status?: string;
created_at: string;
gateway_id: string;
heartbeat_config?: AgentReadHeartbeatConfig;
id: string;
identity_profile?: AgentReadIdentityProfile;
identity_template?: string | null;
soul_template?: string | null;
id: string;
gateway_id: string;
is_board_lead?: boolean;
is_gateway_main?: boolean;
openclaw_session_id?: string | null;
last_seen_at: string | null;
created_at: string;
/** @minLength 1 */
name: string;
openclaw_session_id?: string | null;
soul_template?: string | null;
status?: string;
updated_at: string;
}

6
frontend/src/api/generated/model/agentUpdate.ts
View File

@@ -12,11 +12,11 @@ import type { AgentUpdateIdentityProfile } from "./agentUpdateIdentityProfile";
*/
export interface AgentUpdate {
board_id?: string | null;
is_gateway_main?: boolean | null;
name?: string | null;
status?: string | null;
heartbeat_config?: AgentUpdateHeartbeatConfig;
identity_profile?: AgentUpdateIdentityProfile;
identity_template?: string | null;
is_gateway_main?: boolean | null;
name?: string | null;
soul_template?: string | null;
status?: string | null;
}

8
frontend/src/api/generated/model/approvalCreate.ts
View File

@@ -13,15 +13,15 @@ import type { ApprovalCreateStatus } from "./approvalCreateStatus";
*/
export interface ApprovalCreate {
action_type: string;
task_id?: string | null;
task_ids?: string[];
payload?: ApprovalCreatePayload;
agent_id?: string | null;
/**
* @minimum 0
* @maximum 100
*/
confidence: number;
payload?: ApprovalCreatePayload;
rubric_scores?: ApprovalCreateRubricScores;
status?: ApprovalCreateStatus;
agent_id?: string | null;
task_id?: string | null;
task_ids?: string[];
}

16
frontend/src/api/generated/model/approvalRead.ts
View File

@@ -13,20 +13,20 @@ import type { ApprovalReadStatus } from "./approvalReadStatus";
*/
export interface ApprovalRead {
action_type: string;
task_id?: string | null;
task_ids?: string[];
payload?: ApprovalReadPayload;
agent_id?: string | null;
board_id: string;
/**
* @minimum 0
* @maximum 100
*/
confidence: number;
created_at: string;
id: string;
payload?: ApprovalReadPayload;
resolved_at?: string | null;
rubric_scores?: ApprovalReadRubricScores;
status?: ApprovalReadStatus;
id: string;
board_id: string;
task_id?: string | null;
task_ids?: string[];
task_titles?: string[];
agent_id?: string | null;
created_at: string;
resolved_at?: string | null;
}

2
frontend/src/api/generated/model/blockedTaskDetail.ts
View File

@@ -9,6 +9,6 @@
* Error detail payload listing blocking dependency task identifiers.
*/
export interface BlockedTaskDetail {
message: string;
blocked_by_task_ids?: string[];
message: string;
}

17
frontend/src/api/generated/model/boardCreate.ts
View File

@@ -10,18 +10,19 @@ import type { BoardCreateSuccessMetrics } from "./boardCreateSuccessMetrics";
* Payload for creating a board.
*/
export interface BoardCreate {
name: string;
slug: string;
description: string;
gateway_id?: string | null;
block_status_changes_with_pending_approval?: boolean;
board_group_id?: string | null;
board_type?: string;
objective?: string | null;
success_metrics?: BoardCreateSuccessMetrics;
target_date?: string | null;
description: string;
gateway_id?: string | null;
goal_confirmed?: boolean;
goal_source?: string | null;
name: string;
objective?: string | null;
only_lead_can_change_status?: boolean;
require_approval_for_done?: boolean;
require_review_before_done?: boolean;
block_status_changes_with_pending_approval?: boolean;
slug: string;
success_metrics?: BoardCreateSuccessMetrics;
target_date?: string | null;
}

2
frontend/src/api/generated/model/boardGroupCreate.ts
View File

@@ -9,7 +9,7 @@
* Payload for creating a board group.
*/
export interface BoardGroupCreate {
description?: string | null;
name: string;
slug: string;
description?: string | null;
}

2
frontend/src/api/generated/model/boardGroupHeartbeatApply.ts
View File

@@ -10,6 +10,6 @@
*/
export interface BoardGroupHeartbeatApply {
every: string;
target?: string | null;
include_board_leads?: boolean;
target?: string | null;
}

2
frontend/src/api/generated/model/boardGroupHeartbeatApplyResult.ts
View File

@@ -11,7 +11,7 @@ import type { BoardGroupHeartbeatApplyResultRequested } from "./boardGroupHeartb
*/
export interface BoardGroupHeartbeatApplyResult {
board_group_id: string;
failed_agent_ids: string[];
requested: BoardGroupHeartbeatApplyResultRequested;
updated_agent_ids: string[];
failed_agent_ids: string[];
}

2
frontend/src/api/generated/model/boardGroupMemoryCreate.ts
View File

@@ -11,6 +11,6 @@
export interface BoardGroupMemoryCreate {
/** @minLength 1 */
content: string;
tags?: string[] | null;
source?: string | null;
tags?: string[] | null;
}

8
frontend/src/api/generated/model/boardGroupMemoryRead.ts
View File

@@ -9,11 +9,11 @@
* Serialized board-group memory entry returned from read endpoints.
*/
export interface BoardGroupMemoryRead {
id: string;
board_group_id: string;
content: string;
tags?: string[] | null;
source?: string | null;
is_chat?: boolean;
created_at: string;
id: string;
is_chat?: boolean;
source?: string | null;
tags?: string[] | null;
}

6
frontend/src/api/generated/model/boardGroupRead.ts
View File

@@ -9,11 +9,11 @@
* Board-group payload returned from read endpoints.
*/
export interface BoardGroupRead {
name: string;
slug: string;
created_at: string;
description?: string | null;
id: string;
name: string;
organization_id: string;
created_at: string;
slug: string;
updated_at: string;
}

2
frontend/src/api/generated/model/boardGroupSnapshot.ts
View File

@@ -11,6 +11,6 @@ import type { BoardGroupRead } from "./boardGroupRead";
* Top-level board-group snapshot response payload.
*/
export interface BoardGroupSnapshot {
group?: BoardGroupRead | null;
boards?: BoardGroupBoardSnapshot[];
group?: BoardGroupRead | null;
}

18
frontend/src/api/generated/model/boardGroupTaskSummary.ts
View File

@@ -10,17 +10,17 @@ import type { TagRef } from "./tagRef";
* Task summary row used inside board-group snapshot responses.
*/
export interface BoardGroupTaskSummary {
id: string;
board_id: string;
board_name: string;
title: string;
status: string;
priority: string;
assigned_agent_id?: string | null;
assignee?: string | null;
due_at?: string | null;
in_progress_at?: string | null;
tags?: TagRef[];
board_id: string;
board_name: string;
created_at: string;
due_at?: string | null;
id: string;
in_progress_at?: string | null;
priority: string;
status: string;
tags?: TagRef[];
title: string;
updated_at: string;
}

2
frontend/src/api/generated/model/boardGroupUpdate.ts
View File

@@ -9,7 +9,7 @@
* Payload for partial board-group updates.
*/
export interface BoardGroupUpdate {
description?: string | null;
name?: string | null;
slug?: string | null;
description?: string | null;
}

2
frontend/src/api/generated/model/boardMemoryCreate.ts
View File

@@ -11,6 +11,6 @@
export interface BoardMemoryCreate {
/** @minLength 1 */
content: string;
tags?: string[] | null;
source?: string | null;
tags?: string[] | null;
}

8
frontend/src/api/generated/model/boardMemoryRead.ts
View File

@@ -9,11 +9,11 @@
* Serialized board memory entry returned from read endpoints.
*/
export interface BoardMemoryRead {
id: string;
board_id: string;
content: string;
tags?: string[] | null;
source?: string | null;
is_chat?: boolean;
created_at: string;
id: string;
is_chat?: boolean;
source?: string | null;
tags?: string[] | null;
}

4
frontend/src/api/generated/model/boardOnboardingAgentComplete.ts
View File

@@ -13,10 +13,10 @@ import type { BoardOnboardingUserProfile } from "./boardOnboardingUserProfile";
*/
export interface BoardOnboardingAgentComplete {
board_type: string;
lead_agent?: BoardOnboardingLeadAgentDraft | null;
objective?: string | null;
status: "complete";
success_metrics?: BoardOnboardingAgentCompleteSuccessMetrics;
target_date?: string | null;
status: "complete";
user_profile?: BoardOnboardingUserProfile | null;
lead_agent?: BoardOnboardingLeadAgentDraft | null;
}

4
frontend/src/api/generated/model/boardOnboardingAgentQuestion.ts
View File

@@ -10,8 +10,8 @@ import type { BoardOnboardingQuestionOption } from "./boardOnboardingQuestionOpt
* Question payload emitted by the onboarding assistant.
*/
export interface BoardOnboardingAgentQuestion {
/** @minLength 1 */
question: string;
/** @minItems 1 */
options: BoardOnboardingQuestionOption[];
/** @minLength 1 */
question: string;
}

8
frontend/src/api/generated/model/boardOnboardingLeadAgentDraft.ts
View File

@@ -10,11 +10,11 @@ import type { BoardOnboardingLeadAgentDraftIdentityProfile } from "./boardOnboar
* Editable lead-agent draft configuration.
*/
export interface BoardOnboardingLeadAgentDraft {
name?: string | null;
identity_profile?: BoardOnboardingLeadAgentDraftIdentityProfile;
autonomy_level?: "ask_first" | "balanced" | "autonomous" | null;
verbosity?: "concise" | "balanced" | "detailed" | null;
custom_instructions?: string | null;
identity_profile?: BoardOnboardingLeadAgentDraftIdentityProfile;
name?: string | null;
output_format?: "bullets" | "mixed" | "narrative" | null;
update_cadence?: "asap" | "hourly" | "daily" | "weekly" | null;
custom_instructions?: string | null;
verbosity?: "concise" | "balanced" | "detailed" | null;
}

8
frontend/src/api/generated/model/boardOnboardingRead.ts
View File

@@ -11,12 +11,12 @@ import type { BoardOnboardingReadMessages } from "./boardOnboardingReadMessages"
* Stored onboarding session state returned by API endpoints.
*/
export interface BoardOnboardingRead {
id: string;
board_id: string;
created_at: string;
draft_goal?: BoardOnboardingAgentComplete | null;
id: string;
messages?: BoardOnboardingReadMessages;
session_key: string;
status: string;
messages?: BoardOnboardingReadMessages;
draft_goal?: BoardOnboardingAgentComplete | null;
created_at: string;
updated_at: string;
}

4
frontend/src/api/generated/model/boardOnboardingUserProfile.ts
View File

@@ -9,9 +9,9 @@
* User-profile preferences gathered during onboarding.
*/
export interface BoardOnboardingUserProfile {
context?: string | null;
notes?: string | null;
preferred_name?: string | null;
pronouns?: string | null;
timezone?: string | null;
notes?: string | null;
context?: string | null;
}

24
frontend/src/api/generated/model/boardRead.ts
View File

@@ -10,23 +10,23 @@ import type { BoardReadSuccessMetrics } from "./boardReadSuccessMetrics";
* Board payload returned from read endpoints.
*/
export interface BoardRead {
name: string;
slug: string;
description: string;
gateway_id?: string | null;
block_status_changes_with_pending_approval?: boolean;
board_group_id?: string | null;
board_type?: string;
objective?: string | null;
success_metrics?: BoardReadSuccessMetrics;
target_date?: string | null;
created_at: string;
description: string;
gateway_id?: string | null;
goal_confirmed?: boolean;
goal_source?: string | null;
id: string;
name: string;
objective?: string | null;
only_lead_can_change_status?: boolean;
organization_id: string;
require_approval_for_done?: boolean;
require_review_before_done?: boolean;
block_status_changes_with_pending_approval?: boolean;
only_lead_can_change_status?: boolean;
id: string;
organization_id: string;
created_at: string;
slug: string;
success_metrics?: BoardReadSuccessMetrics;
target_date?: string | null;
updated_at: string;
}

4
frontend/src/api/generated/model/boardSnapshot.ts
View File

@@ -14,10 +14,10 @@ import type { TaskCardRead } from "./taskCardRead";
* Aggregated board payload used by board snapshot endpoints.
*/
export interface BoardSnapshot {
board: BoardRead;
tasks: TaskCardRead[];
agents: AgentRead[];
approvals: ApprovalRead[];
board: BoardRead;
chat_messages: BoardMemoryRead[];
pending_approvals_count?: number;
tasks: TaskCardRead[];
}

18
frontend/src/api/generated/model/boardUpdate.ts
View File

@@ -10,19 +10,19 @@ import type { BoardUpdateSuccessMetrics } from "./boardUpdateSuccessMetrics";
* Payload for partial board updates.
*/
export interface BoardUpdate {
name?: string | null;
slug?: string | null;
description?: string | null;
gateway_id?: string | null;
block_status_changes_with_pending_approval?: boolean | null;
board_group_id?: string | null;
board_type?: string | null;
objective?: string | null;
success_metrics?: BoardUpdateSuccessMetrics;
target_date?: string | null;
description?: string | null;
gateway_id?: string | null;
goal_confirmed?: boolean | null;
goal_source?: string | null;
name?: string | null;
objective?: string | null;
only_lead_can_change_status?: boolean | null;
require_approval_for_done?: boolean | null;
require_review_before_done?: boolean | null;
block_status_changes_with_pending_approval?: boolean | null;
only_lead_can_change_status?: boolean | null;
slug?: string | null;
success_metrics?: BoardUpdateSuccessMetrics;
target_date?: string | null;
}

2
frontend/src/api/generated/model/dashboardKpis.ts
View File

@@ -10,7 +10,7 @@
*/
export interface DashboardKpis {
active_agents: number;
tasks_in_progress: number;
error_rate_pct: number;
median_cycle_time_hours_7d: number | null;
tasks_in_progress: number;
}

8
frontend/src/api/generated/model/dashboardMetrics.ts
View File

@@ -13,11 +13,11 @@ import type { DashboardWipSeriesSet } from "./dashboardWipSeriesSet";
* Complete dashboard metrics response payload.
*/
export interface DashboardMetrics {
range: DashboardMetricsRange;
generated_at: string;
kpis: DashboardKpis;
throughput: DashboardSeriesSet;
cycle_time: DashboardSeriesSet;
error_rate: DashboardSeriesSet;
generated_at: string;
kpis: DashboardKpis;
range: DashboardMetricsRange;
throughput: DashboardSeriesSet;
wip: DashboardWipSeriesSet;
}

2
frontend/src/api/generated/model/dashboardRangeSeries.ts
View File

@@ -12,7 +12,7 @@ import type { DashboardSeriesPoint } from "./dashboardSeriesPoint";
* Series payload for a single range/bucket combination.
*/
export interface DashboardRangeSeries {
range: DashboardRangeSeriesRange;
bucket: DashboardRangeSeriesBucket;
points: DashboardSeriesPoint[];
range: DashboardRangeSeriesRange;
}

2
frontend/src/api/generated/model/dashboardSeriesSet.ts
View File

@@ -10,6 +10,6 @@ import type { DashboardRangeSeries } from "./dashboardRangeSeries";
* Primary vs comparison pair for generic series metrics.
*/
export interface DashboardSeriesSet {
primary: DashboardRangeSeries;
comparison: DashboardRangeSeries;
primary: DashboardRangeSeries;
}

8
frontend/src/api/generated/model/dashboardWipPoint.ts
View File

@@ -9,9 +9,9 @@
* Work-in-progress point split by task status buckets.
*/
export interface DashboardWipPoint {
period: string;
inbox: number;
in_progress: number;
review: number;
done: number;
in_progress: number;
inbox: number;
period: string;
review: number;
}

2
frontend/src/api/generated/model/dashboardWipRangeSeries.ts
View File

@@ -12,7 +12,7 @@ import type { DashboardWipRangeSeriesRange } from "./dashboardWipRangeSeriesRang
* WIP series payload for a single range/bucket combination.
*/
export interface DashboardWipRangeSeries {
range: DashboardWipRangeSeriesRange;
bucket: DashboardWipRangeSeriesBucket;
points: DashboardWipPoint[];
range: DashboardWipRangeSeriesRange;
}

2
frontend/src/api/generated/model/dashboardWipSeriesSet.ts
View File

@@ -10,6 +10,6 @@ import type { DashboardWipRangeSeries } from "./dashboardWipRangeSeries";
* Primary vs comparison pair for WIP status series metrics.
*/
export interface DashboardWipSeriesSet {
primary: DashboardWipRangeSeries;
comparison: DashboardWipRangeSeries;
primary: DashboardWipRangeSeries;
}

4
frontend/src/api/generated/model/gatewayCommandsResponse.ts
View File

@@ -9,7 +9,7 @@
* Gateway command catalog and protocol metadata.
*/
export interface GatewayCommandsResponse {
protocol_version: number;
methods: string[];
events: string[];
methods: string[];
protocol_version: number;
}

2
frontend/src/api/generated/model/gatewayCreate.ts
View File

@@ -10,7 +10,7 @@
*/
export interface GatewayCreate {
name: string;
token?: string | null;
url: string;
workspace_root: string;
token?: string | null;
}

2
frontend/src/api/generated/model/gatewayLeadBroadcastBoardResult.ts
View File

@@ -10,8 +10,8 @@
*/
export interface GatewayLeadBroadcastBoardResult {
board_id: string;
error?: string | null;
lead_agent_id?: string | null;
lead_agent_name?: string | null;
ok?: boolean;
error?: string | null;
}

8
frontend/src/api/generated/model/gatewayLeadBroadcastRequest.ts
View File

@@ -10,11 +10,11 @@ import type { GatewayLeadBroadcastRequestKind } from "./gatewayLeadBroadcastRequ
* Request payload for broadcasting a message to multiple board leads.
*/
export interface GatewayLeadBroadcastRequest {
kind?: GatewayLeadBroadcastRequestKind;
correlation_id?: string | null;
board_ids?: string[] | null;
/** @minLength 1 */
content: string;
board_ids?: string[] | null;
reply_tags?: string[];
correlation_id?: string | null;
kind?: GatewayLeadBroadcastRequestKind;
reply_source?: string | null;
reply_tags?: string[];
}

4
frontend/src/api/generated/model/gatewayLeadBroadcastResponse.ts
View File

@@ -10,8 +10,8 @@ import type { GatewayLeadBroadcastBoardResult } from "./gatewayLeadBroadcastBoar
* Aggregate response for a lead broadcast operation.
*/
export interface GatewayLeadBroadcastResponse {
ok?: boolean;
sent?: number;
failed?: number;
ok?: boolean;
results?: GatewayLeadBroadcastBoardResult[];
sent?: number;
}

6
frontend/src/api/generated/model/gatewayLeadMessageRequest.ts
View File

@@ -10,10 +10,10 @@ import type { GatewayLeadMessageRequestKind } from "./gatewayLeadMessageRequestK
* Request payload for sending a message to a board lead agent.
*/
export interface GatewayLeadMessageRequest {
kind?: GatewayLeadMessageRequestKind;
correlation_id?: string | null;
/** @minLength 1 */
content: string;
reply_tags?: string[];
correlation_id?: string | null;
kind?: GatewayLeadMessageRequestKind;
reply_source?: string | null;
reply_tags?: string[];
}

2
frontend/src/api/generated/model/gatewayLeadMessageResponse.ts
View File

@@ -9,9 +9,9 @@
* Response payload for a lead-message dispatch attempt.
*/
export interface GatewayLeadMessageResponse {
ok?: boolean;
board_id: string;
lead_agent_id?: string | null;
lead_agent_name?: string | null;
lead_created?: boolean;
ok?: boolean;
}

4
frontend/src/api/generated/model/gatewayMainAskUserRequest.ts
View File

@@ -9,10 +9,10 @@
* Request payload for asking the end user via a main gateway agent.
*/
export interface GatewayMainAskUserRequest {
correlation_id?: string | null;
/** @minLength 1 */
content: string;
correlation_id?: string | null;
preferred_channel?: string | null;
reply_tags?: string[];
reply_source?: string | null;
reply_tags?: string[];
}

2
frontend/src/api/generated/model/gatewayMainAskUserResponse.ts
View File

@@ -9,8 +9,8 @@
* Response payload for user-question dispatch via gateway main agent.
*/
export interface GatewayMainAskUserResponse {
ok?: boolean;
board_id: string;
main_agent_id?: string | null;
main_agent_name?: string | null;
ok?: boolean;
}

8
frontend/src/api/generated/model/gatewayRead.ts
View File

@@ -9,12 +9,12 @@
* Gateway payload returned from read endpoints.
*/
export interface GatewayRead {
name: string;
url: string;
workspace_root: string;
created_at: string;
id: string;
name: string;
organization_id: string;
token?: string | null;
created_at: string;
updated_at: string;
url: string;
workspace_root: string;
}

2
frontend/src/api/generated/model/gatewaySessionsResponse.ts
View File

@@ -9,6 +9,6 @@
* Gateway sessions list response payload.
*/
export interface GatewaySessionsResponse {
sessions: unknown[];
main_session?: unknown | null;
sessions: unknown[];
}

8
frontend/src/api/generated/model/gatewayTemplatesSyncResult.ts
View File

@@ -10,11 +10,11 @@ import type { GatewayTemplatesSyncError } from "./gatewayTemplatesSyncError";
* Summary payload returned by gateway template sync endpoints.
*/
export interface GatewayTemplatesSyncResult {
agents_skipped: number;
agents_updated: number;
errors?: GatewayTemplatesSyncError[];
gateway_id: string;
include_main: boolean;
reset_sessions: boolean;
agents_updated: number;
agents_skipped: number;
main_updated: boolean;
errors?: GatewayTemplatesSyncError[];
reset_sessions: boolean;
}

2
frontend/src/api/generated/model/gatewayUpdate.ts
View File

@@ -10,7 +10,7 @@
*/
export interface GatewayUpdate {
name?: string | null;
url?: string | null;
token?: string | null;
url?: string | null;
workspace_root?: string | null;
}

6
frontend/src/api/generated/model/gatewaysStatusResponse.ts
View File

@@ -10,10 +10,10 @@
*/
export interface GatewaysStatusResponse {
connected: boolean;
error?: string | null;
gateway_url: string;
sessions_count?: number | null;
sessions?: unknown[] | null;
main_session?: unknown | null;
main_session_error?: string | null;
error?: string | null;
sessions?: unknown[] | null;
sessions_count?: number | null;
}

11
frontend/src/api/generated/model/index.ts
View File

@@ -188,14 +188,25 @@ export * from "./tagRead";
export * from "./tagRef";
export * from "./tagUpdate";
export * from "./taskCardRead";
export * from "./taskCardReadCustomFieldValues";
export * from "./taskCardReadStatus";
export * from "./taskCommentCreate";
export * from "./taskCommentRead";
export * from "./taskCreate";
export * from "./taskCreateCustomFieldValues";
export * from "./taskCreateStatus";
export * from "./taskCustomFieldDefinitionCreate";
export * from "./taskCustomFieldDefinitionCreateFieldType";
export * from "./taskCustomFieldDefinitionCreateUiVisibility";
export * from "./taskCustomFieldDefinitionRead";
export * from "./taskCustomFieldDefinitionReadFieldType";
export * from "./taskCustomFieldDefinitionReadUiVisibility";
export * from "./taskCustomFieldDefinitionUpdate";
export * from "./taskRead";
export * from "./taskReadCustomFieldValues";
export * from "./taskReadStatus";
export * from "./taskUpdate";
export * from "./taskUpdateCustomFieldValues";
export * from "./updateAgentApiV1AgentsAgentIdPatchParams";
export * from "./userRead";
export * from "./userUpdate";

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedActivityEventRead.ts
View File

@@ -8,10 +8,10 @@ import type { ActivityEventRead } from "./activityEventRead";
export interface LimitOffsetPageTypeVarCustomizedActivityEventRead {
items: ActivityEventRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedActivityTaskCommentFeedItemRead.ts
View File

@@ -8,10 +8,10 @@ import type { ActivityTaskCommentFeedItemRead } from "./activityTaskCommentFeedI
export interface LimitOffsetPageTypeVarCustomizedActivityTaskCommentFeedItemRead {
items: ActivityTaskCommentFeedItemRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedAgentRead.ts
View File

@@ -8,10 +8,10 @@ import type { AgentRead } from "./agentRead";
export interface LimitOffsetPageTypeVarCustomizedAgentRead {
items: AgentRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedApprovalRead.ts
View File

@@ -8,10 +8,10 @@ import type { ApprovalRead } from "./approvalRead";
export interface LimitOffsetPageTypeVarCustomizedApprovalRead {
items: ApprovalRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupMemoryRead.ts
View File

@@ -8,10 +8,10 @@ import type { BoardGroupMemoryRead } from "./boardGroupMemoryRead";
export interface LimitOffsetPageTypeVarCustomizedBoardGroupMemoryRead {
items: BoardGroupMemoryRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupRead.ts
View File

@@ -8,10 +8,10 @@ import type { BoardGroupRead } from "./boardGroupRead";
export interface LimitOffsetPageTypeVarCustomizedBoardGroupRead {
items: BoardGroupRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardMemoryRead.ts
View File

@@ -8,10 +8,10 @@ import type { BoardMemoryRead } from "./boardMemoryRead";
export interface LimitOffsetPageTypeVarCustomizedBoardMemoryRead {
items: BoardMemoryRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardRead.ts
View File

@@ -8,10 +8,10 @@ import type { BoardRead } from "./boardRead";
export interface LimitOffsetPageTypeVarCustomizedBoardRead {
items: BoardRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedGatewayRead.ts
View File

@@ -8,10 +8,10 @@ import type { GatewayRead } from "./gatewayRead";
export interface LimitOffsetPageTypeVarCustomizedGatewayRead {
items: GatewayRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedOrganizationInviteRead.ts
View File

@@ -8,10 +8,10 @@ import type { OrganizationInviteRead } from "./organizationInviteRead";
export interface LimitOffsetPageTypeVarCustomizedOrganizationInviteRead {
items: OrganizationInviteRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedOrganizationMemberRead.ts
View File

@@ -8,10 +8,10 @@ import type { OrganizationMemberRead } from "./organizationMemberRead";
export interface LimitOffsetPageTypeVarCustomizedOrganizationMemberRead {
items: OrganizationMemberRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedTagRead.ts
View File

@@ -8,10 +8,10 @@ import type { TagRead } from "./tagRead";
export interface LimitOffsetPageTypeVarCustomizedTagRead {
items: TagRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedTaskCommentRead.ts
View File

@@ -8,10 +8,10 @@ import type { TaskCommentRead } from "./taskCommentRead";
export interface LimitOffsetPageTypeVarCustomizedTaskCommentRead {
items: TaskCommentRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

4
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedTaskRead.ts
View File

@@ -8,10 +8,10 @@ import type { TaskRead } from "./taskRead";
export interface LimitOffsetPageTypeVarCustomizedTaskRead {
items: TaskRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
/** @minimum 0 */
total: number;
}

2
frontend/src/api/generated/model/organizationBoardAccessRead.ts
View File

@@ -9,10 +9,10 @@
* Board access payload returned from read endpoints.
*/
export interface OrganizationBoardAccessRead {
id: string;
board_id: string;
can_read: boolean;
can_write: boolean;
created_at: string;
id: string;
updated_at: string;
}

4
frontend/src/api/generated/model/organizationInviteCreate.ts
View File

@@ -10,9 +10,9 @@ import type { OrganizationBoardAccessSpec } from "./organizationBoardAccessSpec"
* Payload for creating an organization invite.
*/
export interface OrganizationInviteCreate {
invited_email: string;
role?: string;
all_boards_read?: boolean;
all_boards_write?: boolean;
board_access?: OrganizationBoardAccessSpec[];
invited_email: string;
role?: string;
}

16
frontend/src/api/generated/model/organizationInviteRead.ts
View File

@@ -9,16 +9,16 @@
* Organization invite payload returned from read endpoints.
*/
export interface OrganizationInviteRead {
id: string;
organization_id: string;
invited_email: string;
role: string;
accepted_at?: string | null;
accepted_by_user_id?: string | null;
all_boards_read: boolean;
all_boards_write: boolean;
token: string;
created_by_user_id?: string | null;
accepted_by_user_id?: string | null;
accepted_at?: string | null;
created_at: string;
created_by_user_id?: string | null;
id: string;
invited_email: string;
organization_id: string;
role: string;
token: string;
updated_at: string;
}

2
frontend/src/api/generated/model/organizationListItem.ts
View File

@@ -10,7 +10,7 @@
*/
export interface OrganizationListItem {
id: string;
is_active: boolean;
name: string;
role: string;
is_active: boolean;
}

10
frontend/src/api/generated/model/organizationMemberRead.ts
View File

@@ -11,14 +11,14 @@ import type { OrganizationUserRead } from "./organizationUserRead";
* Organization member payload including board-level access overrides.
*/
export interface OrganizationMemberRead {
id: string;
organization_id: string;
user_id: string;
role: string;
all_boards_read: boolean;
all_boards_write: boolean;
board_access?: OrganizationBoardAccessRead[];
created_at: string;
id: string;
organization_id: string;
role: string;
updated_at: string;
user?: OrganizationUserRead | null;
board_access?: OrganizationBoardAccessRead[];
user_id: string;
}

2
frontend/src/api/generated/model/organizationRead.ts
View File

@@ -9,8 +9,8 @@
* Organization payload returned by read endpoints.
*/
export interface OrganizationRead {
created_at: string;
id: string;
name: string;
created_at: string;
updated_at: string;
}

2
frontend/src/api/generated/model/organizationUserRead.ts
View File

@@ -9,8 +9,8 @@
* Embedded user fields included in organization member payloads.
*/
export interface OrganizationUserRead {
id: string;
email?: string | null;
id: string;
name?: string | null;
preferred_name?: string | null;
}

2
frontend/src/api/generated/model/soulUpdateRequest.ts
View File

@@ -10,6 +10,6 @@
*/
export interface SoulUpdateRequest {
content: string;
source_url?: string | null;
reason?: string | null;
source_url?: string | null;
}

2
frontend/src/api/generated/model/soulsDirectoryMarkdownResponse.ts
View File

@@ -9,7 +9,7 @@
* Response payload containing rendered markdown for a soul.
*/
export interface SoulsDirectoryMarkdownResponse {
content: string;
handle: string;
slug: string;
content: string;
}

2
frontend/src/api/generated/model/soulsDirectorySoulRef.ts
View File

@@ -10,7 +10,7 @@
*/
export interface SoulsDirectorySoulRef {
handle: string;
slug: string;
page_url: string;
raw_md_url: string;
slug: string;
}

4
frontend/src/api/generated/model/tagCreate.ts
View File

@@ -9,9 +9,9 @@
* Payload for creating a tag.
*/
export interface TagCreate {
color?: string;
description?: string | null;
/** @minLength 1 */
name: string;
slug?: string | null;
color?: string;
description?: string | null;
}

6
frontend/src/api/generated/model/tagRead.ts
View File

@@ -9,13 +9,13 @@
* Tag payload returned from API endpoints.
*/
export interface TagRead {
name: string;
slug: string;
color?: string;
created_at: string;
description?: string | null;
id: string;
name: string;
organization_id: string;
slug: string;
task_count?: number;
created_at: string;
updated_at: string;
}

2
frontend/src/api/generated/model/tagRef.ts
View File

@@ -9,8 +9,8 @@
* Compact tag representation embedded in task payloads.
*/
export interface TagRef {
color: string;
id: string;
name: string;
slug: string;
color: string;
}

4
frontend/src/api/generated/model/tagUpdate.ts
View File

@@ -9,8 +9,8 @@
* Payload for partial tag updates.
*/
export interface TagUpdate {
name?: string | null;
slug?: string | null;
color?: string | null;
description?: string | null;
name?: string | null;
slug?: string | null;
}

38
frontend/src/api/generated/model/taskCardRead.ts
View File

@@ -5,30 +5,32 @@
* OpenAPI spec version: 0.1.0
*/
import type { TagRef } from "./tagRef";
import type { TaskCardReadCustomFieldValues } from "./taskCardReadCustomFieldValues";
import type { TaskCardReadStatus } from "./taskCardReadStatus";
/**
* Task read model enriched with assignee and approval counters.
*/
export interface TaskCardRead {
title: string;
description?: string | null;
status?: TaskCardReadStatus;
priority?: string;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_ids?: string[];
tag_ids?: string[];
id: string;
board_id: string | null;
created_by_user_id: string | null;
in_progress_at: string | null;
created_at: string;
updated_at: string;
blocked_by_task_ids?: string[];
is_blocked?: boolean;
tags?: TagRef[];
assignee?: string | null;
approvals_count?: number;
approvals_pending_count?: number;
assigned_agent_id?: string | null;
assignee?: string | null;
blocked_by_task_ids?: string[];
board_id: string | null;
created_at: string;
created_by_user_id: string | null;
custom_field_values?: TaskCardReadCustomFieldValues;
depends_on_task_ids?: string[];
description?: string | null;
due_at?: string | null;
id: string;
in_progress_at: string | null;
is_blocked?: boolean;
priority?: string;
status?: TaskCardReadStatus;
tag_ids?: string[];
tags?: TagRef[];
title: string;
updated_at: string;
}

10
frontend/src/api/generated/model/taskCardReadCustomFieldValues.ts Normal file
View File

@@ -0,0 +1,10 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCardReadCustomFieldValues = {
[key: string]: unknown | null;
} | null;

4
frontend/src/api/generated/model/taskCommentRead.ts
View File

@@ -9,9 +9,9 @@
* Task comment payload returned from read endpoints.
*/
export interface TaskCommentRead {
agent_id: string | null;
created_at: string;
id: string;
message: string | null;
agent_id: string | null;
task_id: string | null;
created_at: string;
}

16
frontend/src/api/generated/model/taskCreate.ts
View File

@@ -4,19 +4,21 @@
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { TaskCreateCustomFieldValues } from "./taskCreateCustomFieldValues";
import type { TaskCreateStatus } from "./taskCreateStatus";
/**
* Payload for creating a task.
*/
export interface TaskCreate {
title: string;
description?: string | null;
status?: TaskCreateStatus;
priority?: string;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_ids?: string[];
tag_ids?: string[];
created_by_user_id?: string | null;
custom_field_values?: TaskCreateCustomFieldValues;
depends_on_task_ids?: string[];
description?: string | null;
due_at?: string | null;
priority?: string;
status?: TaskCreateStatus;
tag_ids?: string[];
title: string;
}

8
frontend/src/api/generated/model/taskCreateCustomFieldValues.ts Normal file
View File

@@ -0,0 +1,8 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCreateCustomFieldValues = { [key: string]: unknown | null };

25
frontend/src/api/generated/model/taskCustomFieldDefinitionCreate.ts Normal file
View File

@@ -0,0 +1,25 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { TaskCustomFieldDefinitionCreateFieldType } from "./taskCustomFieldDefinitionCreateFieldType";
import type { TaskCustomFieldDefinitionCreateUiVisibility } from "./taskCustomFieldDefinitionCreateUiVisibility";
/**
* Payload for creating a task custom field definition.
*/
export interface TaskCustomFieldDefinitionCreate {
/** @minItems 1 */
board_ids: string[];
default_value?: unknown | null;
description?: string | null;
/** @minLength 1 */
field_key: string;
field_type?: TaskCustomFieldDefinitionCreateFieldType;
label?: string | null;
required?: boolean;
ui_visibility?: TaskCustomFieldDefinitionCreateUiVisibility;
validation_regex?: string | null;
}

21
frontend/src/api/generated/model/taskCustomFieldDefinitionCreateFieldType.ts Normal file
View File

@@ -0,0 +1,21 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCustomFieldDefinitionCreateFieldType =
(typeof TaskCustomFieldDefinitionCreateFieldType)[keyof typeof TaskCustomFieldDefinitionCreateFieldType];
export const TaskCustomFieldDefinitionCreateFieldType = {
text: "text",
text_long: "text_long",
integer: "integer",
decimal: "decimal",
boolean: "boolean",
date: "date",
date_time: "date_time",
url: "url",
json: "json",
} as const;

15
frontend/src/api/generated/model/taskCustomFieldDefinitionCreateUiVisibility.ts Normal file
View File

@@ -0,0 +1,15 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCustomFieldDefinitionCreateUiVisibility =
(typeof TaskCustomFieldDefinitionCreateUiVisibility)[keyof typeof TaskCustomFieldDefinitionCreateUiVisibility];
export const TaskCustomFieldDefinitionCreateUiVisibility = {
always: "always",
if_set: "if_set",
hidden: "hidden",
} as const;

27
frontend/src/api/generated/model/taskCustomFieldDefinitionRead.ts Normal file
View File

@@ -0,0 +1,27 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { TaskCustomFieldDefinitionReadFieldType } from "./taskCustomFieldDefinitionReadFieldType";
import type { TaskCustomFieldDefinitionReadUiVisibility } from "./taskCustomFieldDefinitionReadUiVisibility";
/**
* Payload returned for custom field definitions.
*/
export interface TaskCustomFieldDefinitionRead {
board_ids?: string[];
created_at: string;
default_value?: unknown | null;
description?: string | null;
field_key: string;
field_type: TaskCustomFieldDefinitionReadFieldType;
id: string;
label: string;
organization_id: string;
required?: boolean;
ui_visibility: TaskCustomFieldDefinitionReadUiVisibility;
updated_at: string;
validation_regex?: string | null;
}

21
frontend/src/api/generated/model/taskCustomFieldDefinitionReadFieldType.ts Normal file
View File

@@ -0,0 +1,21 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCustomFieldDefinitionReadFieldType =
(typeof TaskCustomFieldDefinitionReadFieldType)[keyof typeof TaskCustomFieldDefinitionReadFieldType];
export const TaskCustomFieldDefinitionReadFieldType = {
text: "text",
text_long: "text_long",
integer: "integer",
decimal: "decimal",
boolean: "boolean",
date: "date",
date_time: "date_time",
url: "url",
json: "json",
} as const;

15
frontend/src/api/generated/model/taskCustomFieldDefinitionReadUiVisibility.ts Normal file
View File

@@ -0,0 +1,15 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskCustomFieldDefinitionReadUiVisibility =
(typeof TaskCustomFieldDefinitionReadUiVisibility)[keyof typeof TaskCustomFieldDefinitionReadUiVisibility];
export const TaskCustomFieldDefinitionReadUiVisibility = {
always: "always",
if_set: "if_set",
hidden: "hidden",
} as const;

30
frontend/src/api/generated/model/taskCustomFieldDefinitionUpdate.ts Normal file
View File

@@ -0,0 +1,30 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
/**
* Payload for editing an existing task custom field definition.
*/
export interface TaskCustomFieldDefinitionUpdate {
board_ids?: string[] | null;
default_value?: unknown | null;
description?: string | null;
field_type?:
| "text"
| "text_long"
| "integer"
| "decimal"
| "boolean"
| "date"
| "date_time"
| "url"
| "json"
| null;
label?: string | null;
required?: boolean | null;
ui_visibility?: "always" | "if_set" | "hidden" | null;
validation_regex?: string | null;
}

28
frontend/src/api/generated/model/taskRead.ts
View File

@@ -5,27 +5,29 @@
* OpenAPI spec version: 0.1.0
*/
import type { TagRef } from "./tagRef";
import type { TaskReadCustomFieldValues } from "./taskReadCustomFieldValues";
import type { TaskReadStatus } from "./taskReadStatus";
/**
* Task payload returned from read endpoints.
*/
export interface TaskRead {
title: string;
description?: string | null;
status?: TaskReadStatus;
priority?: string;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_ids?: string[];
tag_ids?: string[];
id: string;
board_id: string | null;
created_by_user_id: string | null;
in_progress_at: string | null;
created_at: string;
updated_at: string;
blocked_by_task_ids?: string[];
board_id: string | null;
created_at: string;
created_by_user_id: string | null;
custom_field_values?: TaskReadCustomFieldValues;
depends_on_task_ids?: string[];
description?: string | null;
due_at?: string | null;
id: string;
in_progress_at: string | null;
is_blocked?: boolean;
priority?: string;
status?: TaskReadStatus;
tag_ids?: string[];
tags?: TagRef[];
title: string;
updated_at: string;
}

10
frontend/src/api/generated/model/taskReadCustomFieldValues.ts Normal file
View File

@@ -0,0 +1,10 @@
/**
* Generated by orval v8.3.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type TaskReadCustomFieldValues = {
[key: string]: unknown | null;
} | null;

Some files were not shown because too many files have changed in this diff Show More