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

feat: add board group models and update related interfaces

Browse Source
This commit is contained in:
Abhimanyu Saharan
2026-02-07 20:29:50 +05:30
parent 7b5ee230f5
commit 88a5075684
170 changed files with 12372 additions and 3697 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@@ -362,133 +362,6 @@ export const useCreateAgentApiV1AgentsPost = <
queryClient,
);
};
/**
* @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,
);
};
/**
* @summary Stream Agents
*/
@@ -700,122 +573,6 @@ export function useStreamAgentsApiV1AgentsStreamGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* @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,
);
};
/**
* @summary Get Agent
*/
@@ -1175,6 +932,122 @@ export const useUpdateAgentApiV1AgentsAgentIdPatch = <
queryClient,
);
};
/**
* @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,
);
};
/**
* @summary Heartbeat Agent
*/
@@ -1302,3 +1175,130 @@ export const useHeartbeatAgentApiV1AgentsAgentIdHeartbeatPost = <
queryClient,
);
};
/**
* @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,
);
};

1596
frontend/src/api/generated/board-group-memory/board-group-memory.ts Normal file
View File

File diff suppressed because it is too large Load Diff

1286
frontend/src/api/generated/board-groups/board-groups.ts Normal file
View File

File diff suppressed because it is too large Load Diff

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

@@ -273,6 +273,296 @@ export function useGetOnboardingApiV1BoardsBoardIdOnboardingGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* @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,
);
};
/**
* @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,
);
};
/**
* @summary Agent Onboarding Update
*/
@@ -447,155 +737,6 @@ export const useAgentOnboardingUpdateApiV1BoardsBoardIdOnboardingAgentPost = <
queryClient,
);
};
/**
* @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,
);
};
/**
* @summary Confirm Onboarding
*/
@@ -749,144 +890,3 @@ export const useConfirmOnboardingApiV1BoardsBoardIdOnboardingConfirmPost = <
queryClient,
);
};
/**
* @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,
);
};

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

@@ -22,9 +22,11 @@ import type {
import type {
BoardCreate,
BoardGroupSnapshot,
BoardRead,
BoardSnapshot,
BoardUpdate,
GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
HTTPValidationError,
LimitOffsetPageTypeVarCustomizedBoardRead,
ListBoardsApiV1BoardsGetParams,
@@ -359,122 +361,6 @@ export const useCreateBoardApiV1BoardsPost = <
queryClient,
);
};
/**
* @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,
);
};
/**
* @summary Get Board
*/
@@ -793,6 +679,122 @@ export const useUpdateBoardApiV1BoardsBoardIdPatch = <
queryClient,
);
};
/**
* @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,
);
};
/**
* @summary Get Board Snapshot
*/
@@ -1030,3 +1032,305 @@ export function useGetBoardSnapshotApiV1BoardsBoardIdSnapshotGet<
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* @summary Get Board Group Snapshot
*/
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse200 =
{
data: BoardGroupSnapshot;
status: 200;
};
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse422 =
{
data: HTTPValidationError;
status: 422;
};
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponseSuccess =
getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse200 & {
headers: Headers;
};
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponseError =
getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse422 & {
headers: Headers;
};
export type getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse =
| getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponseSuccess
| getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponseError;
export const getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetUrl = (
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : value.toString());
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/boards/${boardId}/group-snapshot?${stringifiedParams}`
: `/api/v1/boards/${boardId}/group-snapshot`;
};
export const getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet = async (
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options?: RequestInit,
): Promise<getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse> => {
return customFetch<getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetResponse>(
getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetUrl(
boardId,
params,
),
{
...options,
method: "GET",
},
);
};
export const getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryKey =
(
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
) => {
return [
`/api/v1/boards/${boardId}/group-snapshot`,
...(params ? [params] : []),
] as const;
};
export const getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryOptions =
<
TData = Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
) => {
const { query: queryOptions, request: requestOptions } = options ?? {};
const queryKey =
queryOptions?.queryKey ??
getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryKey(
boardId,
params,
);
const queryFn: QueryFunction<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>
> = ({ signal }) =>
getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet(boardId, params, {
signal,
...requestOptions,
});
return {
queryKey,
queryFn,
enabled: !!boardId,
...queryOptions,
} as UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
> & { queryKey: DataTag<QueryKey, TData, TError> };
};
export type GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryResult =
NonNullable<
Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>
>;
export type GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryError =
HTTPValidationError;
export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params:
| undefined
| GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options: {
query: Partial<
UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
>
> &
Pick<
DefinedInitialDataOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
>
> &
Pick<
UndefinedInitialDataOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
/**
* @summary Get Board Group Snapshot
*/
export function useGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet<
TData = Awaited<
ReturnType<typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<
ReturnType<
typeof getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGet
>
>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
} {
const queryOptions =
getGetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetQueryOptions(
boardId,
params,
options,
);
const query = useQuery(queryOptions, queryClient) as UseQueryResult<
TData,
TError
> & { queryKey: DataTag<QueryKey, TData, TError> };
return { ...query, queryKey: queryOptions.queryKey };
}

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

File diff suppressed because it is too large Load Diff

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

@@ -6,10 +6,10 @@
*/
export interface ActivityEventRead {
agent_id: string | null;
created_at: string;
event_type: string;
id: string;
event_type: string;
message: string | null;
agent_id: string | null;
task_id: string | null;
created_at: string;
}

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

@@ -6,14 +6,14 @@
*/
export interface ActivityTaskCommentFeedItemRead {
id: string;
created_at: string;
message: string | null;
agent_id: string | null;
agent_name?: string | null;
agent_role?: string | null;
board_id: string;
board_name: string;
created_at: string;
id: string;
message: string | null;
task_id: string;
task_title: string;
board_id: string;
board_name: string;
}

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

@@ -9,11 +9,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

@@ -6,8 +6,8 @@
*/
export interface AgentHeartbeatCreate {
board_id?: string | null;
status?: string | null;
/** @minLength 1 */
name: string;
status?: string | null;
board_id?: string | null;
}

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

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

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

@@ -9,11 +9,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;
}

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

@@ -10,10 +10,10 @@ import type { ApprovalCreateStatus } from "./approvalCreateStatus";
export interface ApprovalCreate {
action_type: string;
agent_id?: string | null;
confidence: number;
task_id?: string | null;
payload?: ApprovalCreatePayload;
confidence: number;
rubric_scores?: ApprovalCreateRubricScores;
status?: ApprovalCreateStatus;
task_id?: string | null;
agent_id?: string | null;
}

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

@@ -10,14 +10,14 @@ import type { ApprovalReadStatus } from "./approvalReadStatus";
export interface ApprovalRead {
action_type: string;
agent_id?: string | null;
board_id: string;
confidence: number;
created_at: string;
id: string;
task_id?: string | null;
payload?: ApprovalReadPayload;
resolved_at?: string | null;
confidence: number;
rubric_scores?: ApprovalReadRubricScores;
status?: ApprovalReadStatus;
task_id?: string | null;
id: string;
board_id: string;
agent_id?: string | null;
created_at: string;
resolved_at?: string | null;
}

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

@@ -6,6 +6,6 @@
*/
export interface BlockedTaskDetail {
blocked_by_task_ids?: string[];
message: string;
blocked_by_task_ids?: string[];
}

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

@@ -7,13 +7,14 @@
import type { BoardCreateSuccessMetrics } from "./boardCreateSuccessMetrics";
export interface BoardCreate {
board_type?: string;
gateway_id: string;
goal_confirmed?: boolean;
goal_source?: string | null;
name: string;
objective?: string | null;
slug: string;
gateway_id: string;
board_group_id?: string | null;
board_type?: string;
objective?: string | null;
success_metrics?: BoardCreateSuccessMetrics;
target_date?: string | null;
goal_confirmed?: boolean;
goal_source?: string | null;
}

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

@@ -0,0 +1,15 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { BoardGroupBoardSnapshotTaskCounts } from "./boardGroupBoardSnapshotTaskCounts";
import type { BoardGroupTaskSummary } from "./boardGroupTaskSummary";
import type { BoardRead } from "./boardRead";
export interface BoardGroupBoardSnapshot {
board: BoardRead;
task_counts?: BoardGroupBoardSnapshotTaskCounts;
tasks?: BoardGroupTaskSummary[];
}

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

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

12
frontend/src/api/generated/model/boardGroupCreate.ts Normal file
View File

@@ -0,0 +1,12 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupCreate {
name: string;
slug: string;
description?: string | null;
}

12
frontend/src/api/generated/model/boardGroupHeartbeatApply.ts Normal file
View File

@@ -0,0 +1,12 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupHeartbeatApply {
every: string;
target?: string | null;
include_board_leads?: boolean;
}

14
frontend/src/api/generated/model/boardGroupHeartbeatApplyResult.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { BoardGroupHeartbeatApplyResultRequested } from "./boardGroupHeartbeatApplyResultRequested";
export interface BoardGroupHeartbeatApplyResult {
board_group_id: string;
requested: BoardGroupHeartbeatApplyResultRequested;
updated_agent_ids: string[];
failed_agent_ids: string[];
}

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

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

13
frontend/src/api/generated/model/boardGroupMemoryCreate.ts Normal file
View File

@@ -0,0 +1,13 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupMemoryCreate {
/** @minLength 1 */
content: string;
tags?: string[] | null;
source?: string | null;
}

16
frontend/src/api/generated/model/boardGroupMemoryRead.ts Normal file
View File

@@ -0,0 +1,16 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupMemoryRead {
id: string;
board_group_id: string;
content: string;
tags?: string[] | null;
source?: string | null;
is_chat?: boolean;
created_at: string;
}

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

@@ -0,0 +1,15 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupRead {
name: string;
slug: string;
description?: string | null;
id: string;
created_at: string;
updated_at: string;
}

13
frontend/src/api/generated/model/boardGroupSnapshot.ts Normal file
View File

@@ -0,0 +1,13 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { BoardGroupBoardSnapshot } from "./boardGroupBoardSnapshot";
import type { BoardGroupRead } from "./boardGroupRead";
export interface BoardGroupSnapshot {
group?: BoardGroupRead | null;
boards?: BoardGroupBoardSnapshot[];
}

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

@@ -0,0 +1,21 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
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;
created_at: string;
updated_at: string;
}

12
frontend/src/api/generated/model/boardGroupUpdate.ts Normal file
View File

@@ -0,0 +1,12 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface BoardGroupUpdate {
name?: string | null;
slug?: string | null;
description?: string | null;
}

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

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

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

@@ -6,11 +6,11 @@
*/
export interface BoardMemoryRead {
id: string;
board_id: string;
content: string;
created_at: string;
id: string;
is_chat?: boolean;
source?: string | null;
tags?: string[] | null;
source?: string | null;
is_chat?: boolean;
created_at: string;
}

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

@@ -10,10 +10,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

@@ -7,8 +7,8 @@
import type { BoardOnboardingQuestionOption } from "./boardOnboardingQuestionOption";
export interface BoardOnboardingAgentQuestion {
/** @minItems 1 */
options: BoardOnboardingQuestionOption[];
/** @minLength 1 */
question: string;
/** @minItems 1 */
options: BoardOnboardingQuestionOption[];
}

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

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

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

@@ -8,12 +8,12 @@ import type { BoardOnboardingAgentComplete } from "./boardOnboardingAgentComplet
import type { BoardOnboardingReadMessages } from "./boardOnboardingReadMessages";
export interface BoardOnboardingRead {
board_id: string;
created_at: string;
draft_goal?: BoardOnboardingAgentComplete | null;
id: string;
messages?: BoardOnboardingReadMessages;
board_id: string;
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

@@ -6,9 +6,9 @@
*/
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;
}

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

@@ -7,16 +7,17 @@
import type { BoardReadSuccessMetrics } from "./boardReadSuccessMetrics";
export interface BoardRead {
board_type?: string;
created_at: string;
name: string;
slug: string;
gateway_id?: string | null;
board_group_id?: string | null;
board_type?: string;
objective?: string | null;
success_metrics?: BoardReadSuccessMetrics;
target_date?: string | null;
goal_confirmed?: boolean;
goal_source?: string | null;
id: string;
name: string;
objective?: string | null;
slug: string;
success_metrics?: BoardReadSuccessMetrics;
target_date?: string | null;
created_at: string;
updated_at: string;
}

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

@@ -11,10 +11,10 @@ import type { BoardRead } from "./boardRead";
import type { TaskCardRead } from "./taskCardRead";
export interface BoardSnapshot {
board: BoardRead;
tasks: TaskCardRead[];
agents: AgentRead[];
approvals: ApprovalRead[];
board: BoardRead;
chat_messages: BoardMemoryRead[];
pending_approvals_count?: number;
tasks: TaskCardRead[];
}

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

@@ -7,13 +7,14 @@
import type { BoardUpdateSuccessMetrics } from "./boardUpdateSuccessMetrics";
export interface BoardUpdate {
board_type?: string | null;
gateway_id?: string | null;
goal_confirmed?: boolean | null;
goal_source?: string | null;
name?: string | null;
objective?: string | null;
slug?: string | null;
gateway_id?: string | null;
board_group_id?: string | null;
board_type?: string | null;
objective?: string | null;
success_metrics?: BoardUpdateSuccessMetrics;
target_date?: string | null;
goal_confirmed?: boolean | null;
goal_source?: string | null;
}

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

@@ -7,7 +7,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;
}

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

@@ -10,11 +10,11 @@ import type { DashboardSeriesSet } from "./dashboardSeriesSet";
import type { DashboardWipSeriesSet } from "./dashboardWipSeriesSet";
export interface DashboardMetrics {
cycle_time: DashboardSeriesSet;
error_rate: DashboardSeriesSet;
range: DashboardMetricsRange;
generated_at: string;
kpis: DashboardKpis;
range: DashboardMetricsRange;
throughput: DashboardSeriesSet;
cycle_time: DashboardSeriesSet;
error_rate: DashboardSeriesSet;
wip: DashboardWipSeriesSet;
}

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

@@ -9,7 +9,7 @@ import type { DashboardRangeSeriesRange } from "./dashboardRangeSeriesRange";
import type { DashboardSeriesPoint } from "./dashboardSeriesPoint";
export interface DashboardRangeSeries {
range: DashboardRangeSeriesRange;
bucket: DashboardRangeSeriesBucket;
points: DashboardSeriesPoint[];
range: DashboardRangeSeriesRange;
}

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

@@ -7,6 +7,6 @@
import type { DashboardRangeSeries } from "./dashboardRangeSeries";
export interface DashboardSeriesSet {
comparison: DashboardRangeSeries;
primary: DashboardRangeSeries;
comparison: DashboardRangeSeries;
}

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

@@ -6,8 +6,8 @@
*/
export interface DashboardWipPoint {
in_progress: number;
inbox: number;
period: string;
inbox: number;
in_progress: number;
review: number;
}

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

@@ -9,7 +9,7 @@ import type { DashboardWipRangeSeriesBucket } from "./dashboardWipRangeSeriesBuc
import type { DashboardWipRangeSeriesRange } from "./dashboardWipRangeSeriesRange";
export interface DashboardWipRangeSeries {
range: DashboardWipRangeSeriesRange;
bucket: DashboardWipRangeSeriesBucket;
points: DashboardWipPoint[];
range: DashboardWipRangeSeriesRange;
}

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

@@ -7,6 +7,6 @@
import type { DashboardWipRangeSeries } from "./dashboardWipRangeSeries";
export interface DashboardWipSeriesSet {
comparison: DashboardWipRangeSeries;
primary: DashboardWipRangeSeries;
comparison: DashboardWipRangeSeries;
}

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

@@ -6,7 +6,7 @@
*/
export interface GatewayCommandsResponse {
events: string[];
methods: string[];
protocol_version: number;
methods: string[];
events: string[];
}

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

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

14
frontend/src/api/generated/model/gatewayLeadBroadcastBoardResult.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface GatewayLeadBroadcastBoardResult {
board_id: string;
lead_agent_id?: string | null;
lead_agent_name?: string | null;
ok?: boolean;
error?: string | null;
}

17
frontend/src/api/generated/model/gatewayLeadBroadcastRequest.ts Normal file
View File

@@ -0,0 +1,17 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { GatewayLeadBroadcastRequestKind } from "./gatewayLeadBroadcastRequestKind";
export interface GatewayLeadBroadcastRequest {
kind?: GatewayLeadBroadcastRequestKind;
correlation_id?: string | null;
/** @minLength 1 */
content: string;
board_ids?: string[] | null;
reply_tags?: string[];
reply_source?: string | null;
}

14
frontend/src/api/generated/model/gatewayLeadBroadcastRequestKind.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type GatewayLeadBroadcastRequestKind =
(typeof GatewayLeadBroadcastRequestKind)[keyof typeof GatewayLeadBroadcastRequestKind];
export const GatewayLeadBroadcastRequestKind = {
question: "question",
handoff: "handoff",
} as const;

14
frontend/src/api/generated/model/gatewayLeadBroadcastResponse.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { GatewayLeadBroadcastBoardResult } from "./gatewayLeadBroadcastBoardResult";
export interface GatewayLeadBroadcastResponse {
ok?: boolean;
sent?: number;
failed?: number;
results?: GatewayLeadBroadcastBoardResult[];
}

16
frontend/src/api/generated/model/gatewayLeadMessageRequest.ts Normal file
View File

@@ -0,0 +1,16 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { GatewayLeadMessageRequestKind } from "./gatewayLeadMessageRequestKind";
export interface GatewayLeadMessageRequest {
kind?: GatewayLeadMessageRequestKind;
correlation_id?: string | null;
/** @minLength 1 */
content: string;
reply_tags?: string[];
reply_source?: string | null;
}

14
frontend/src/api/generated/model/gatewayLeadMessageRequestKind.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type GatewayLeadMessageRequestKind =
(typeof GatewayLeadMessageRequestKind)[keyof typeof GatewayLeadMessageRequestKind];
export const GatewayLeadMessageRequestKind = {
question: "question",
handoff: "handoff",
} as const;

14
frontend/src/api/generated/model/gatewayLeadMessageResponse.ts Normal file
View File

@@ -0,0 +1,14 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface GatewayLeadMessageResponse {
ok?: boolean;
board_id: string;
lead_agent_id?: string | null;
lead_agent_name?: string | null;
lead_created?: boolean;
}

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

@@ -0,0 +1,15 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface GatewayMainAskUserRequest {
correlation_id?: string | null;
/** @minLength 1 */
content: string;
preferred_channel?: string | null;
reply_tags?: string[];
reply_source?: string | null;
}

13
frontend/src/api/generated/model/gatewayMainAskUserResponse.ts Normal file
View File

@@ -0,0 +1,13 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export interface GatewayMainAskUserResponse {
ok?: boolean;
board_id: string;
main_agent_id?: string | null;
main_agent_name?: string | null;
}

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

@@ -6,12 +6,12 @@
*/
export interface GatewayRead {
created_at: string;
id: string;
main_session_key: string;
name: string;
token?: string | null;
updated_at: string;
url: string;
main_session_key: string;
workspace_root: string;
id: string;
token?: string | null;
created_at: string;
updated_at: string;
}

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

@@ -6,7 +6,7 @@
*/
export interface GatewaySessionsResponse {
main_session?: unknown | null;
main_session_key?: string | null;
sessions: unknown[];
main_session_key?: string | null;
main_session?: unknown | null;
}

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

@@ -7,11 +7,11 @@
import type { GatewayTemplatesSyncError } from "./gatewayTemplatesSyncError";
export interface GatewayTemplatesSyncResult {
agents_skipped: number;
agents_updated: number;
errors?: GatewayTemplatesSyncError[];
gateway_id: string;
include_main: boolean;
main_updated: boolean;
reset_sessions: boolean;
agents_updated: number;
agents_skipped: number;
main_updated: boolean;
errors?: GatewayTemplatesSyncError[];
}

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

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

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

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

11
frontend/src/api/generated/model/getBoardGroupSnapshotApiV1BoardGroupsGroupIdSnapshotGetParams.ts Normal file
View File

@@ -0,0 +1,11 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type GetBoardGroupSnapshotApiV1BoardGroupsGroupIdSnapshotGetParams = {
include_done?: boolean;
per_board_task_limit?: number;
};

16
frontend/src/api/generated/model/getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams.ts Normal file
View File

@@ -0,0 +1,16 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type GetBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams = {
include_self?: boolean;
include_done?: boolean;
/**
* @minimum 0
* @maximum 100
*/
per_board_task_limit?: number;
};

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

@@ -34,6 +34,18 @@ export * from "./blockedTaskDetail";
export * from "./blockedTaskError";
export * from "./boardCreate";
export * from "./boardCreateSuccessMetrics";
export * from "./boardGroupBoardSnapshot";
export * from "./boardGroupBoardSnapshotTaskCounts";
export * from "./boardGroupCreate";
export * from "./boardGroupHeartbeatApply";
export * from "./boardGroupHeartbeatApplyResult";
export * from "./boardGroupHeartbeatApplyResultRequested";
export * from "./boardGroupMemoryCreate";
export * from "./boardGroupMemoryRead";
export * from "./boardGroupRead";
export * from "./boardGroupSnapshot";
export * from "./boardGroupTaskSummary";
export * from "./boardGroupUpdate";
export * from "./boardMemoryCreate";
export * from "./boardMemoryRead";
export * from "./boardOnboardingAgentComplete";
@@ -78,6 +90,15 @@ export * from "./deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete200";
export * from "./gatewayCommandsApiV1GatewayCommandsGet200";
export * from "./gatewayCommandsResponse";
export * from "./gatewayCreate";
export * from "./gatewayLeadBroadcastBoardResult";
export * from "./gatewayLeadBroadcastRequest";
export * from "./gatewayLeadBroadcastRequestKind";
export * from "./gatewayLeadBroadcastResponse";
export * from "./gatewayLeadMessageRequest";
export * from "./gatewayLeadMessageRequestKind";
export * from "./gatewayLeadMessageResponse";
export * from "./gatewayMainAskUserRequest";
export * from "./gatewayMainAskUserResponse";
export * from "./gatewayRead";
export * from "./gatewaySessionHistoryResponse";
export * from "./gatewaySessionMessageRequest";
@@ -90,6 +111,8 @@ export * from "./gatewayStatusApiV1GatewayStatusGetParams";
export * from "./gatewayTemplatesSyncError";
export * from "./gatewayTemplatesSyncResult";
export * from "./gatewayUpdate";
export * from "./getBoardGroupSnapshotApiV1BoardGroupsGroupIdSnapshotGetParams";
export * from "./getBoardGroupSnapshotApiV1BoardsBoardIdGroupSnapshotGetParams";
export * from "./getGatewaySessionApiV1GatewaySessionsSessionIdGet200";
export * from "./getGatewaySessionApiV1GatewaySessionsSessionIdGetParams";
export * from "./getGatewaySessionApiV1GatewaysSessionsSessionIdGetParams";
@@ -103,6 +126,8 @@ export * from "./limitOffsetPageTypeVarCustomizedActivityEventRead";
export * from "./limitOffsetPageTypeVarCustomizedActivityTaskCommentFeedItemRead";
export * from "./limitOffsetPageTypeVarCustomizedAgentRead";
export * from "./limitOffsetPageTypeVarCustomizedApprovalRead";
export * from "./limitOffsetPageTypeVarCustomizedBoardGroupMemoryRead";
export * from "./limitOffsetPageTypeVarCustomizedBoardGroupRead";
export * from "./limitOffsetPageTypeVarCustomizedBoardMemoryRead";
export * from "./limitOffsetPageTypeVarCustomizedBoardRead";
export * from "./limitOffsetPageTypeVarCustomizedGatewayRead";
@@ -113,6 +138,9 @@ export * from "./listAgentsApiV1AgentAgentsGetParams";
export * from "./listAgentsApiV1AgentsGetParams";
export * from "./listApprovalsApiV1AgentBoardsBoardIdApprovalsGetParams";
export * from "./listApprovalsApiV1BoardsBoardIdApprovalsGetParams";
export * from "./listBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryGetParams";
export * from "./listBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryGetParams";
export * from "./listBoardGroupsApiV1BoardGroupsGetParams";
export * from "./listBoardMemoryApiV1AgentBoardsBoardIdMemoryGetParams";
export * from "./listBoardMemoryApiV1BoardsBoardIdMemoryGetParams";
export * from "./listBoardsApiV1AgentBoardsGetParams";
@@ -134,6 +162,8 @@ export * from "./sendSessionMessageApiV1GatewaySessionsSessionIdMessagePostBody"
export * from "./sendSessionMessageApiV1GatewaySessionsSessionIdMessagePostParams";
export * from "./streamAgentsApiV1AgentsStreamGetParams";
export * from "./streamApprovalsApiV1BoardsBoardIdApprovalsStreamGetParams";
export * from "./streamBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryStreamGetParams";
export * from "./streamBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryStreamGetParams";
export * from "./streamBoardMemoryApiV1BoardsBoardIdMemoryStreamGetParams";
export * from "./streamTaskCommentFeedApiV1ActivityTaskCommentsStreamGetParams";
export * from "./streamTasksApiV1BoardsBoardIdTasksStreamGetParams";

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

17
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupMemoryRead.ts Normal file
View File

@@ -0,0 +1,17 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { BoardGroupMemoryRead } from "./boardGroupMemoryRead";
export interface LimitOffsetPageTypeVarCustomizedBoardGroupMemoryRead {
items: BoardGroupMemoryRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: number;
}

17
frontend/src/api/generated/model/limitOffsetPageTypeVarCustomizedBoardGroupRead.ts Normal file
View File

@@ -0,0 +1,17 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
import type { BoardGroupRead } from "./boardGroupRead";
export interface LimitOffsetPageTypeVarCustomizedBoardGroupRead {
items: BoardGroupRead[];
/** @minimum 0 */
total: number;
/** @minimum 1 */
limit: number;
/** @minimum 0 */
offset: 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/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;
}

19
frontend/src/api/generated/model/listBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryGetParams.ts Normal file
View File

@@ -0,0 +1,19 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type ListBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryGetParams = {
is_chat?: boolean | null;
/**
* @minimum 1
* @maximum 200
*/
limit?: number;
/**
* @minimum 0
*/
offset?: number;
};

20
frontend/src/api/generated/model/listBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryGetParams.ts Normal file
View File

@@ -0,0 +1,20 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type ListBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryGetParams =
{
is_chat?: boolean | null;
/**
* @minimum 1
* @maximum 200
*/
limit?: number;
/**
* @minimum 0
*/
offset?: number;
};

18
frontend/src/api/generated/model/listBoardGroupsApiV1BoardGroupsGetParams.ts Normal file
View File

@@ -0,0 +1,18 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type ListBoardGroupsApiV1BoardGroupsGetParams = {
/**
* @minimum 1
* @maximum 200
*/
limit?: number;
/**
* @minimum 0
*/
offset?: number;
};

1
frontend/src/api/generated/model/listBoardsApiV1BoardsGetParams.ts
View File

@@ -7,6 +7,7 @@
export type ListBoardsApiV1BoardsGetParams = {
gateway_id?: string | null;
board_group_id?: string | null;
/**
* @minimum 1
* @maximum 200

12
frontend/src/api/generated/model/streamBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryStreamGetParams.ts Normal file
View File

@@ -0,0 +1,12 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type StreamBoardGroupMemoryApiV1BoardGroupsGroupIdMemoryStreamGetParams =
{
since?: string | null;
is_chat?: boolean | null;
};

12
frontend/src/api/generated/model/streamBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryStreamGetParams.ts Normal file
View File

@@ -0,0 +1,12 @@
/**
* Generated by orval v8.2.0 🍺
* Do not edit manually.
* Mission Control API
* OpenAPI spec version: 0.1.0
*/
export type StreamBoardGroupMemoryForBoardApiV1BoardsBoardIdGroupMemoryStreamGetParams =
{
since?: string | null;
is_chat?: boolean | null;
};

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

@@ -7,22 +7,22 @@
import type { TaskCardReadStatus } from "./taskCardReadStatus";
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[];
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;
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;
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;
title: string;
updated_at: string;
}

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

@@ -6,9 +6,9 @@
*/
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;
}

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

@@ -7,12 +7,12 @@
import type { TaskCreateStatus } from "./taskCreateStatus";
export interface TaskCreate {
assigned_agent_id?: string | null;
created_by_user_id?: string | null;
depends_on_task_ids?: string[];
description?: string | null;
due_at?: string | null;
priority?: string;
status?: TaskCreateStatus;
title: string;
description?: string | null;
status?: TaskCreateStatus;
priority?: string;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_ids?: string[];
created_by_user_id?: string | null;
}

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

@@ -7,19 +7,19 @@
import type { TaskReadStatus } from "./taskReadStatus";
export interface TaskRead {
assigned_agent_id?: string | null;
blocked_by_task_ids?: string[];
board_id: string | null;
created_at: string;
created_by_user_id: string | null;
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;
title: string;
description?: string | null;
status?: TaskReadStatus;
priority?: string;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_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;
}

14
frontend/src/api/generated/model/taskUpdate.ts
View File

@@ -6,12 +6,12 @@
*/
export interface TaskUpdate {
assigned_agent_id?: string | null;
comment?: string | null;
depends_on_task_ids?: string[] | null;
description?: string | null;
due_at?: string | null;
priority?: string | null;
status?: "inbox" | "in_progress" | "review" | "done" | null;
title?: string | null;
description?: string | null;
status?: "inbox" | "in_progress" | "review" | "done" | null;
priority?: string | null;
due_at?: string | null;
assigned_agent_id?: string | null;
depends_on_task_ids?: string[] | null;
comment?: string | null;
}

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

@@ -7,13 +7,13 @@
export interface UserRead {
clerk_user_id: string;
context?: string | null;
email?: string | null;
id: string;
is_super_admin: boolean;
name?: string | null;
notes?: string | null;
preferred_name?: string | null;
pronouns?: string | null;
timezone?: string | null;
notes?: string | null;
context?: string | null;
id: string;
is_super_admin: boolean;
}

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

@@ -6,10 +6,10 @@
*/
export interface UserUpdate {
context?: string | null;
name?: string | null;
notes?: string | null;
preferred_name?: string | null;
pronouns?: string | null;
timezone?: string | null;
notes?: string | null;
context?: string | null;
}

754
frontend/src/api/generated/tasks/tasks.ts
View File

@@ -40,6 +40,258 @@ import { customFetch } from "../../mutator";
type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
/**
* @summary Stream Tasks
*/
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse200 = {
data: unknown;
status: 200;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponseSuccess =
streamTasksApiV1BoardsBoardIdTasksStreamGetResponse200 & {
headers: Headers;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponseError =
streamTasksApiV1BoardsBoardIdTasksStreamGetResponse422 & {
headers: Headers;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse =
| streamTasksApiV1BoardsBoardIdTasksStreamGetResponseSuccess
| streamTasksApiV1BoardsBoardIdTasksStreamGetResponseError;
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetUrl = (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : value.toString());
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/boards/${boardId}/tasks/stream?${stringifiedParams}`
: `/api/v1/boards/${boardId}/tasks/stream`;
};
export const streamTasksApiV1BoardsBoardIdTasksStreamGet = async (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: RequestInit,
): Promise<streamTasksApiV1BoardsBoardIdTasksStreamGetResponse> => {
return customFetch<streamTasksApiV1BoardsBoardIdTasksStreamGetResponse>(
getStreamTasksApiV1BoardsBoardIdTasksStreamGetUrl(boardId, params),
{
...options,
method: "GET",
},
);
};
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryKey = (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
) => {
return [
`/api/v1/boards/${boardId}/tasks/stream`,
...(params ? [params] : []),
] as const;
};
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryOptions = <
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
) => {
const { query: queryOptions, request: requestOptions } = options ?? {};
const queryKey =
queryOptions?.queryKey ??
getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryKey(boardId, params);
const queryFn: QueryFunction<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>
> = ({ signal }) =>
streamTasksApiV1BoardsBoardIdTasksStreamGet(boardId, params, {
signal,
...requestOptions,
});
return {
queryKey,
queryFn,
enabled: !!boardId,
...queryOptions,
} as UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
> & { queryKey: DataTag<QueryKey, TData, TError> };
};
export type StreamTasksApiV1BoardsBoardIdTasksStreamGetQueryResult =
NonNullable<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>
>;
export type StreamTasksApiV1BoardsBoardIdTasksStreamGetQueryError =
HTTPValidationError;
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params: undefined | StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options: {
query: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
> &
Pick<
DefinedInitialDataOptions<
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError,
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
> &
Pick<
UndefinedInitialDataOptions<
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError,
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
/**
* @summary Stream Tasks
*/
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
} {
const queryOptions =
getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryOptions(
boardId,
params,
options,
);
const query = useQuery(queryOptions, queryClient) as UseQueryResult<
TData,
TError
> & { queryKey: DataTag<QueryKey, TData, TError> };
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* @summary List Tasks
*/
@@ -400,383 +652,6 @@ export const useCreateTaskApiV1BoardsBoardIdTasksPost = <
queryClient,
);
};
/**
* @summary Stream Tasks
*/
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse200 = {
data: unknown;
status: 200;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponseSuccess =
streamTasksApiV1BoardsBoardIdTasksStreamGetResponse200 & {
headers: Headers;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponseError =
streamTasksApiV1BoardsBoardIdTasksStreamGetResponse422 & {
headers: Headers;
};
export type streamTasksApiV1BoardsBoardIdTasksStreamGetResponse =
| streamTasksApiV1BoardsBoardIdTasksStreamGetResponseSuccess
| streamTasksApiV1BoardsBoardIdTasksStreamGetResponseError;
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetUrl = (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : value.toString());
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/boards/${boardId}/tasks/stream?${stringifiedParams}`
: `/api/v1/boards/${boardId}/tasks/stream`;
};
export const streamTasksApiV1BoardsBoardIdTasksStreamGet = async (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: RequestInit,
): Promise<streamTasksApiV1BoardsBoardIdTasksStreamGetResponse> => {
return customFetch<streamTasksApiV1BoardsBoardIdTasksStreamGetResponse>(
getStreamTasksApiV1BoardsBoardIdTasksStreamGetUrl(boardId, params),
{
...options,
method: "GET",
},
);
};
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryKey = (
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
) => {
return [
`/api/v1/boards/${boardId}/tasks/stream`,
...(params ? [params] : []),
] as const;
};
export const getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryOptions = <
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
) => {
const { query: queryOptions, request: requestOptions } = options ?? {};
const queryKey =
queryOptions?.queryKey ??
getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryKey(boardId, params);
const queryFn: QueryFunction<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>
> = ({ signal }) =>
streamTasksApiV1BoardsBoardIdTasksStreamGet(boardId, params, {
signal,
...requestOptions,
});
return {
queryKey,
queryFn,
enabled: !!boardId,
...queryOptions,
} as UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
> & { queryKey: DataTag<QueryKey, TData, TError> };
};
export type StreamTasksApiV1BoardsBoardIdTasksStreamGetQueryResult =
NonNullable<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>
>;
export type StreamTasksApiV1BoardsBoardIdTasksStreamGetQueryError =
HTTPValidationError;
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params: undefined | StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options: {
query: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
> &
Pick<
DefinedInitialDataOptions<
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError,
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): DefinedUseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
> &
Pick<
UndefinedInitialDataOptions<
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError,
Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>
>,
"initialData"
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
};
/**
* @summary Stream Tasks
*/
export function useStreamTasksApiV1BoardsBoardIdTasksStreamGet<
TData = Awaited<
ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>
>,
TError = HTTPValidationError,
>(
boardId: string,
params?: StreamTasksApiV1BoardsBoardIdTasksStreamGetParams,
options?: {
query?: Partial<
UseQueryOptions<
Awaited<ReturnType<typeof streamTasksApiV1BoardsBoardIdTasksStreamGet>>,
TError,
TData
>
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseQueryResult<TData, TError> & {
queryKey: DataTag<QueryKey, TData, TError>;
} {
const queryOptions =
getStreamTasksApiV1BoardsBoardIdTasksStreamGetQueryOptions(
boardId,
params,
options,
);
const query = useQuery(queryOptions, queryClient) as UseQueryResult<
TData,
TError
> & { queryKey: DataTag<QueryKey, TData, TError> };
return { ...query, queryKey: queryOptions.queryKey };
}
/**
* @summary Delete Task
*/
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseSuccess =
deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse200 & {
headers: Headers;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseError =
deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse422 & {
headers: Headers;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse =
| deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseSuccess
| deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseError;
export const getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteUrl = (
boardId: string,
taskId: string,
) => {
return `/api/v1/boards/${boardId}/tasks/${taskId}`;
};
export const deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete = async (
boardId: string,
taskId: string,
options?: RequestInit,
): Promise<deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse> => {
return customFetch<deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse>(
getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteUrl(boardId, taskId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
> => {
const mutationKey = ["deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete"];
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 deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
{ boardId: string; taskId: string }
> = (props) => {
const { boardId, taskId } = props ?? {};
return deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete(
boardId,
taskId,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationResult =
NonNullable<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>
>;
export type DeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Task
*/
export const useDeleteTaskApiV1BoardsBoardIdTasksTaskIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
> => {
return useMutation(
getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* @summary Update Task
*/
@@ -915,6 +790,131 @@ export const useUpdateTaskApiV1BoardsBoardIdTasksTaskIdPatch = <
queryClient,
);
};
/**
* @summary Delete Task
*/
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse200 = {
data: OkResponse;
status: 200;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse422 = {
data: HTTPValidationError;
status: 422;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseSuccess =
deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse200 & {
headers: Headers;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseError =
deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse422 & {
headers: Headers;
};
export type deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse =
| deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseSuccess
| deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponseError;
export const getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteUrl = (
boardId: string,
taskId: string,
) => {
return `/api/v1/boards/${boardId}/tasks/${taskId}`;
};
export const deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete = async (
boardId: string,
taskId: string,
options?: RequestInit,
): Promise<deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse> => {
return customFetch<deleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteResponse>(
getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteUrl(boardId, taskId),
{
...options,
method: "DELETE",
},
);
};
export const getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationOptions = <
TError = HTTPValidationError,
TContext = unknown,
>(options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
}): UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
> => {
const mutationKey = ["deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete"];
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 deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
{ boardId: string; taskId: string }
> = (props) => {
const { boardId, taskId } = props ?? {};
return deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete(
boardId,
taskId,
requestOptions,
);
};
return { mutationFn, ...mutationOptions };
};
export type DeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationResult =
NonNullable<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>
>;
export type DeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationError =
HTTPValidationError;
/**
* @summary Delete Task
*/
export const useDeleteTaskApiV1BoardsBoardIdTasksTaskIdDelete = <
TError = HTTPValidationError,
TContext = unknown,
>(
options?: {
mutation?: UseMutationOptions<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
>;
request?: SecondParameter<typeof customFetch>;
},
queryClient?: QueryClient,
): UseMutationResult<
Awaited<ReturnType<typeof deleteTaskApiV1BoardsBoardIdTasksTaskIdDelete>>,
TError,
{ boardId: string; taskId: string },
TContext
> => {
return useMutation(
getDeleteTaskApiV1BoardsBoardIdTasksTaskIdDeleteMutationOptions(options),
queryClient,
);
};
/**
* @summary List Task Comments
*/

14
frontend/src/api/mutator.ts
View File

@@ -35,7 +35,7 @@ const resolveClerkToken = async (): Promise<string | null> => {
export const customFetch = async <T>(
url: string,
options: RequestInit
options: RequestInit,
): Promise<T> => {
const rawBaseUrl = process.env.NEXT_PUBLIC_API_URL;
if (!rawBaseUrl) {
@@ -79,7 +79,11 @@ export const customFetch = async <T>(
message = detail;
} else if (Array.isArray(detail) && detail.length) {
const first = detail[0] as { msg?: unknown };
if (first && typeof first === "object" && typeof first.msg === "string") {
if (
first &&
typeof first === "object" &&
typeof first.msg === "string"
) {
message = first.msg;
}
}
@@ -110,5 +114,9 @@ export const customFetch = async <T>(
} as T;
}
const text = await response.text().catch(() => "");
return { data: text, status: response.status, headers: response.headers } as T;
return {
data: text,
status: response.status,
headers: response.headers,
} as T;
};