2020-04-10 05:27:57 +02:00
|
|
|
import gql from 'graphql-tag';
|
|
|
|
import * as ApolloReactCommon from '@apollo/react-common';
|
|
|
|
import * as ApolloReactHooks from '@apollo/react-hooks';
|
|
|
|
export type Maybe<T> = T | null;
|
|
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
|
|
export type Scalars = {
|
|
|
|
ID: string;
|
|
|
|
String: string;
|
|
|
|
Boolean: boolean;
|
|
|
|
Int: number;
|
|
|
|
Float: number;
|
|
|
|
Time: any;
|
|
|
|
UUID: string;
|
2020-06-13 00:21:58 +02:00
|
|
|
Upload: any;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
|
2020-06-13 00:21:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export enum RoleCode {
|
|
|
|
Owner = 'owner',
|
|
|
|
Admin = 'admin',
|
|
|
|
Member = 'member',
|
|
|
|
Observer = 'observer'
|
|
|
|
}
|
|
|
|
|
2020-04-21 01:04:27 +02:00
|
|
|
export type ProjectLabel = {
|
|
|
|
__typename?: 'ProjectLabel';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-21 01:04:27 +02:00
|
|
|
createdDate: Scalars['Time'];
|
2020-05-27 23:18:50 +02:00
|
|
|
labelColor: LabelColor;
|
2020-04-21 01:04:27 +02:00
|
|
|
name?: Maybe<Scalars['String']>;
|
|
|
|
};
|
|
|
|
|
2020-05-27 23:18:50 +02:00
|
|
|
export type LabelColor = {
|
|
|
|
__typename?: 'LabelColor';
|
|
|
|
id: Scalars['ID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
colorHex: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type TaskLabel = {
|
|
|
|
__typename?: 'TaskLabel';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-05-31 06:11:19 +02:00
|
|
|
projectLabel: ProjectLabel;
|
2020-04-21 01:04:27 +02:00
|
|
|
assignedDate: Scalars['Time'];
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
export type ProfileIcon = {
|
|
|
|
__typename?: 'ProfileIcon';
|
|
|
|
url?: Maybe<Scalars['String']>;
|
|
|
|
initials?: Maybe<Scalars['String']>;
|
2020-04-21 01:04:27 +02:00
|
|
|
bgColor?: Maybe<Scalars['String']>;
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type OwnersList = {
|
|
|
|
__typename?: 'OwnersList';
|
|
|
|
projects: Array<Scalars['UUID']>;
|
|
|
|
teams: Array<Scalars['UUID']>;
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type Member = {
|
|
|
|
__typename?: 'Member';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-07-05 01:02:57 +02:00
|
|
|
role: Role;
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName: Scalars['String'];
|
2020-07-05 01:02:57 +02:00
|
|
|
username: Scalars['String'];
|
2020-04-20 05:02:55 +02:00
|
|
|
profileIcon: ProfileIcon;
|
2020-07-18 02:40:05 +02:00
|
|
|
owned: OwnedList;
|
|
|
|
member: MemberList;
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type RefreshToken = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'RefreshToken';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
userId: Scalars['UUID'];
|
|
|
|
expiresAt: Scalars['Time'];
|
|
|
|
createdAt: Scalars['Time'];
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type Role = {
|
|
|
|
__typename?: 'Role';
|
|
|
|
code: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-07-18 02:40:05 +02:00
|
|
|
export type OwnedList = {
|
|
|
|
__typename?: 'OwnedList';
|
|
|
|
teams: Array<Team>;
|
|
|
|
projects: Array<Project>;
|
|
|
|
};
|
|
|
|
|
|
|
|
export type MemberList = {
|
|
|
|
__typename?: 'MemberList';
|
|
|
|
teams: Array<Team>;
|
|
|
|
projects: Array<Project>;
|
|
|
|
};
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type UserAccount = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'UserAccount';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
email: Scalars['String'];
|
|
|
|
createdAt: Scalars['Time'];
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName: Scalars['String'];
|
|
|
|
initials: Scalars['String'];
|
2020-07-05 01:02:57 +02:00
|
|
|
role: Role;
|
2020-04-10 05:27:57 +02:00
|
|
|
username: Scalars['String'];
|
2020-04-20 05:02:55 +02:00
|
|
|
profileIcon: ProfileIcon;
|
2020-07-18 02:40:05 +02:00
|
|
|
owned: OwnedList;
|
|
|
|
member: MemberList;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
export type Team = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'Team';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
createdAt: Scalars['Time'];
|
|
|
|
name: Scalars['String'];
|
2020-07-05 01:02:57 +02:00
|
|
|
members: Array<Member>;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
export type Project = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'Project';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
createdAt: Scalars['Time'];
|
|
|
|
name: Scalars['String'];
|
2020-04-20 05:02:55 +02:00
|
|
|
team: Team;
|
2020-07-05 01:02:57 +02:00
|
|
|
owner: Member;
|
2020-04-10 05:27:57 +02:00
|
|
|
taskGroups: Array<TaskGroup>;
|
2020-07-05 01:02:57 +02:00
|
|
|
members: Array<Member>;
|
2020-04-21 01:04:27 +02:00
|
|
|
labels: Array<ProjectLabel>;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
export type TaskGroup = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'TaskGroup';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
projectID: Scalars['String'];
|
|
|
|
createdAt: Scalars['Time'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
tasks: Array<Task>;
|
|
|
|
};
|
|
|
|
|
2020-06-19 23:33:02 +02:00
|
|
|
export type ChecklistBadge = {
|
|
|
|
__typename?: 'ChecklistBadge';
|
|
|
|
complete: Scalars['Int'];
|
|
|
|
total: Scalars['Int'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type TaskBadges = {
|
|
|
|
__typename?: 'TaskBadges';
|
|
|
|
checklist?: Maybe<ChecklistBadge>;
|
|
|
|
};
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type Task = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'Task';
|
2020-05-27 02:53:31 +02:00
|
|
|
id: Scalars['ID'];
|
2020-04-11 04:22:58 +02:00
|
|
|
taskGroup: TaskGroup;
|
2020-04-10 05:27:57 +02:00
|
|
|
createdAt: Scalars['Time'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
2020-04-20 05:02:55 +02:00
|
|
|
description?: Maybe<Scalars['String']>;
|
2020-06-16 00:36:59 +02:00
|
|
|
dueDate?: Maybe<Scalars['Time']>;
|
2020-06-19 01:12:15 +02:00
|
|
|
complete: Scalars['Boolean'];
|
2020-07-05 01:02:57 +02:00
|
|
|
assigned: Array<Member>;
|
2020-04-20 05:02:55 +02:00
|
|
|
labels: Array<TaskLabel>;
|
2020-06-19 01:12:15 +02:00
|
|
|
checklists: Array<TaskChecklist>;
|
2020-06-19 23:33:02 +02:00
|
|
|
badges: TaskBadges;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-06-21 00:49:11 +02:00
|
|
|
export type Organization = {
|
|
|
|
__typename?: 'Organization';
|
|
|
|
id: Scalars['ID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type TaskChecklistItem = {
|
|
|
|
__typename?: 'TaskChecklistItem';
|
|
|
|
id: Scalars['ID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
complete: Scalars['Boolean'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
dueDate: Scalars['Time'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type TaskChecklist = {
|
|
|
|
__typename?: 'TaskChecklist';
|
|
|
|
id: Scalars['ID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
items: Array<TaskChecklistItem>;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type Query = {
|
2020-04-11 04:22:58 +02:00
|
|
|
__typename?: 'Query';
|
2020-06-21 00:49:11 +02:00
|
|
|
organizations: Array<Organization>;
|
2020-04-10 05:27:57 +02:00
|
|
|
users: Array<UserAccount>;
|
|
|
|
findUser: UserAccount;
|
|
|
|
findProject: Project;
|
2020-04-20 05:02:55 +02:00
|
|
|
findTask: Task;
|
2020-04-10 05:27:57 +02:00
|
|
|
projects: Array<Project>;
|
2020-06-23 22:20:53 +02:00
|
|
|
findTeam: Team;
|
2020-06-01 04:20:03 +02:00
|
|
|
teams: Array<Team>;
|
2020-05-27 23:18:50 +02:00
|
|
|
labelColors: Array<LabelColor>;
|
2020-04-10 05:27:57 +02:00
|
|
|
taskGroups: Array<TaskGroup>;
|
2020-04-20 05:02:55 +02:00
|
|
|
me: UserAccount;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type QueryFindUserArgs = {
|
|
|
|
input: FindUser;
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type QueryFindProjectArgs = {
|
|
|
|
input: FindProject;
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type QueryFindTaskArgs = {
|
|
|
|
input: FindTask;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type QueryProjectsArgs = {
|
|
|
|
input?: Maybe<ProjectsFilter>;
|
|
|
|
};
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
|
|
|
|
export type QueryFindTeamArgs = {
|
|
|
|
input: FindTeam;
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type Mutation = {
|
|
|
|
__typename?: 'Mutation';
|
|
|
|
addTaskLabel: Task;
|
|
|
|
assignTask: Task;
|
|
|
|
clearProfileAvatar: UserAccount;
|
|
|
|
createProject: Project;
|
|
|
|
createProjectLabel: ProjectLabel;
|
|
|
|
createProjectMember: CreateProjectMemberPayload;
|
|
|
|
createRefreshToken: RefreshToken;
|
|
|
|
createTask: Task;
|
|
|
|
createTaskChecklist: TaskChecklist;
|
|
|
|
createTaskChecklistItem: TaskChecklistItem;
|
|
|
|
createTaskGroup: TaskGroup;
|
|
|
|
createTeam: Team;
|
|
|
|
createTeamMember: CreateTeamMemberPayload;
|
|
|
|
createUserAccount: UserAccount;
|
|
|
|
deleteProject: DeleteProjectPayload;
|
|
|
|
deleteProjectLabel: ProjectLabel;
|
|
|
|
deleteProjectMember: DeleteProjectMemberPayload;
|
|
|
|
deleteTask: DeleteTaskPayload;
|
|
|
|
deleteTaskChecklist: DeleteTaskChecklistPayload;
|
|
|
|
deleteTaskChecklistItem: DeleteTaskChecklistItemPayload;
|
|
|
|
deleteTaskGroup: DeleteTaskGroupPayload;
|
|
|
|
deleteTeam: DeleteTeamPayload;
|
|
|
|
deleteTeamMember: DeleteTeamMemberPayload;
|
|
|
|
deleteUserAccount: DeleteUserAccountPayload;
|
|
|
|
logoutUser: Scalars['Boolean'];
|
|
|
|
removeTaskLabel: Task;
|
|
|
|
setProjectOwner: SetProjectOwnerPayload;
|
|
|
|
setTaskChecklistItemComplete: TaskChecklistItem;
|
|
|
|
setTaskComplete: Task;
|
|
|
|
setTeamOwner: SetTeamOwnerPayload;
|
|
|
|
toggleTaskLabel: ToggleTaskLabelPayload;
|
|
|
|
unassignTask: Task;
|
|
|
|
updateProjectLabel: ProjectLabel;
|
|
|
|
updateProjectLabelColor: ProjectLabel;
|
|
|
|
updateProjectLabelName: ProjectLabel;
|
|
|
|
updateProjectMemberRole: UpdateProjectMemberRolePayload;
|
|
|
|
updateProjectName: Project;
|
2020-07-12 09:06:11 +02:00
|
|
|
updateTaskChecklistItemLocation: UpdateTaskChecklistItemLocationPayload;
|
2020-07-05 01:02:57 +02:00
|
|
|
updateTaskChecklistItemName: TaskChecklistItem;
|
2020-07-12 09:06:11 +02:00
|
|
|
updateTaskChecklistLocation: UpdateTaskChecklistLocationPayload;
|
2020-07-05 01:02:57 +02:00
|
|
|
updateTaskChecklistName: TaskChecklist;
|
|
|
|
updateTaskDescription: Task;
|
|
|
|
updateTaskDueDate: Task;
|
|
|
|
updateTaskGroupLocation: TaskGroup;
|
|
|
|
updateTaskGroupName: TaskGroup;
|
|
|
|
updateTaskLocation: UpdateTaskLocationPayload;
|
|
|
|
updateTaskName: Task;
|
|
|
|
updateTeamMemberRole: UpdateTeamMemberRolePayload;
|
2020-07-17 02:40:23 +02:00
|
|
|
updateUserPassword: UpdateUserPasswordPayload;
|
2020-07-12 09:06:11 +02:00
|
|
|
updateUserRole: UpdateUserRolePayload;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationAddTaskLabelArgs = {
|
|
|
|
input?: Maybe<AddTaskLabelInput>;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationAssignTaskArgs = {
|
|
|
|
input?: Maybe<AssignTaskInput>;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateProjectArgs = {
|
|
|
|
input: NewProject;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateProjectLabelArgs = {
|
|
|
|
input: NewProjectLabel;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateProjectMemberArgs = {
|
|
|
|
input: CreateProjectMember;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:53:03 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateRefreshTokenArgs = {
|
|
|
|
input: NewRefreshToken;
|
2020-04-11 21:24:45 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateTaskArgs = {
|
|
|
|
input: NewTask;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateTaskChecklistArgs = {
|
|
|
|
input: CreateTaskChecklist;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateTaskChecklistItemArgs = {
|
|
|
|
input: CreateTaskChecklistItem;
|
2020-04-21 01:04:27 +02:00
|
|
|
};
|
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationCreateTaskGroupArgs = {
|
|
|
|
input: NewTaskGroup;
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationCreateTeamArgs = {
|
|
|
|
input: NewTeam;
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationCreateTeamMemberArgs = {
|
|
|
|
input: CreateTeamMember;
|
2020-04-21 01:04:27 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationCreateUserAccountArgs = {
|
|
|
|
input: NewUserAccount;
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteProjectArgs = {
|
|
|
|
input: DeleteProject;
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteProjectLabelArgs = {
|
|
|
|
input: DeleteProjectLabel;
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteProjectMemberArgs = {
|
|
|
|
input: DeleteProjectMember;
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTaskArgs = {
|
|
|
|
input: DeleteTaskInput;
|
2020-05-31 06:11:19 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTaskChecklistArgs = {
|
|
|
|
input: DeleteTaskChecklist;
|
2020-05-31 06:11:19 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTaskChecklistItemArgs = {
|
|
|
|
input: DeleteTaskChecklistItem;
|
2020-05-31 06:11:19 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTaskGroupArgs = {
|
|
|
|
input: DeleteTaskGroupInput;
|
2020-06-01 04:20:03 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTeamArgs = {
|
|
|
|
input: DeleteTeam;
|
2020-06-16 00:36:59 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteTeamMemberArgs = {
|
|
|
|
input: DeleteTeamMember;
|
2020-06-16 00:36:59 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationDeleteUserAccountArgs = {
|
|
|
|
input: DeleteUserAccount;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationLogoutUserArgs = {
|
|
|
|
input: LogoutUser;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationRemoveTaskLabelArgs = {
|
|
|
|
input?: Maybe<RemoveTaskLabelInput>;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationSetProjectOwnerArgs = {
|
|
|
|
input: SetProjectOwner;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationSetTaskChecklistItemCompleteArgs = {
|
|
|
|
input: SetTaskChecklistItemComplete;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationSetTaskCompleteArgs = {
|
|
|
|
input: SetTaskComplete;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationSetTeamOwnerArgs = {
|
|
|
|
input: SetTeamOwner;
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationToggleTaskLabelArgs = {
|
|
|
|
input: ToggleTaskLabelInput;
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUnassignTaskArgs = {
|
|
|
|
input?: Maybe<UnassignTaskInput>;
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateProjectLabelArgs = {
|
|
|
|
input: UpdateProjectLabel;
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateProjectLabelColorArgs = {
|
|
|
|
input: UpdateProjectLabelColor;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateProjectLabelNameArgs = {
|
|
|
|
input: UpdateProjectLabelName;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateProjectMemberRoleArgs = {
|
|
|
|
input: UpdateProjectMemberRole;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateProjectNameArgs = {
|
|
|
|
input?: Maybe<UpdateProjectName>;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type MutationUpdateTaskChecklistItemLocationArgs = {
|
|
|
|
input: UpdateTaskChecklistItemLocation;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskChecklistItemNameArgs = {
|
|
|
|
input: UpdateTaskChecklistItemName;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type MutationUpdateTaskChecklistLocationArgs = {
|
|
|
|
input: UpdateTaskChecklistLocation;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskChecklistNameArgs = {
|
|
|
|
input: UpdateTaskChecklistName;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateTaskDescriptionArgs = {
|
|
|
|
input: UpdateTaskDescriptionInput;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
|
|
|
|
export type MutationUpdateTaskDueDateArgs = {
|
|
|
|
input: UpdateTaskDueDate;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskGroupLocationArgs = {
|
|
|
|
input: NewTaskGroupLocation;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskGroupNameArgs = {
|
|
|
|
input: UpdateTaskGroupName;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskLocationArgs = {
|
|
|
|
input: NewTaskLocation;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTaskNameArgs = {
|
|
|
|
input: UpdateTaskName;
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type MutationUpdateTeamMemberRoleArgs = {
|
|
|
|
input: UpdateTeamMemberRole;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
|
2020-07-17 02:40:23 +02:00
|
|
|
export type MutationUpdateUserPasswordArgs = {
|
|
|
|
input: UpdateUserPassword;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type MutationUpdateUserRoleArgs = {
|
|
|
|
input: UpdateUserRole;
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type ProjectsFilter = {
|
|
|
|
teamID?: Maybe<Scalars['UUID']>;
|
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type FindUser = {
|
|
|
|
userId: Scalars['String'];
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type FindProject = {
|
|
|
|
projectId: Scalars['String'];
|
|
|
|
};
|
2020-06-21 00:49:11 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type FindTask = {
|
|
|
|
taskID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type FindTeam = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewProject = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateProjectName = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
2020-06-21 00:49:11 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProject = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
};
|
2020-06-21 00:49:11 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProjectPayload = {
|
|
|
|
__typename?: 'DeleteProjectPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
project: Project;
|
2020-05-31 06:11:19 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewProjectLabel = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
labelColorID: Scalars['UUID'];
|
|
|
|
name?: Maybe<Scalars['String']>;
|
|
|
|
};
|
2020-05-31 06:11:19 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProjectLabel = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
2020-04-21 01:04:27 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateProjectLabelName = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
2020-04-21 01:04:27 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateProjectLabel = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
labelColorID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateProjectLabelColor = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
labelColorID: Scalars['UUID'];
|
|
|
|
};
|
2020-05-28 03:12:50 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateProjectMember = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateProjectMemberPayload = {
|
|
|
|
__typename?: 'CreateProjectMemberPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
member: Member;
|
|
|
|
};
|
2020-05-28 03:12:50 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProjectMember = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProjectMemberPayload = {
|
|
|
|
__typename?: 'DeleteProjectMemberPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
member: Member;
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
};
|
2020-05-28 03:12:50 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateProjectMemberRole = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
roleCode: RoleCode;
|
2020-05-28 03:12:50 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateProjectMemberRolePayload = {
|
|
|
|
__typename?: 'UpdateProjectMemberRolePayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
member: Member;
|
|
|
|
};
|
2020-05-28 03:12:50 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetProjectOwner = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
ownerID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetProjectOwnerPayload = {
|
|
|
|
__typename?: 'SetProjectOwnerPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
prevOwner: Member;
|
|
|
|
newOwner: Member;
|
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewTask = {
|
|
|
|
taskGroupID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
2020-04-11 04:53:03 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type AssignTaskInput = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
2020-04-11 04:53:03 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UnassignTaskInput = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-06-16 00:36:59 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskDescriptionInput = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
description: Scalars['String'];
|
|
|
|
};
|
2020-06-16 00:36:59 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskLocationPayload = {
|
|
|
|
__typename?: 'UpdateTaskLocationPayload';
|
|
|
|
previousTaskGroupID: Scalars['UUID'];
|
|
|
|
task: Task;
|
2020-04-11 21:24:45 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskDueDate = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
dueDate?: Maybe<Scalars['Time']>;
|
|
|
|
};
|
2020-04-11 21:24:45 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetTaskComplete = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
complete: Scalars['Boolean'];
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewTaskLocation = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskInput = {
|
|
|
|
taskID: Scalars['String'];
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskPayload = {
|
|
|
|
__typename?: 'DeleteTaskPayload';
|
|
|
|
taskID: Scalars['String'];
|
|
|
|
};
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskName = {
|
|
|
|
taskID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
2020-05-31 06:11:19 +02:00
|
|
|
};
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type UpdateTaskChecklistItemLocation = {
|
|
|
|
checklistID: Scalars['UUID'];
|
|
|
|
checklistItemID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistItemLocationPayload = {
|
|
|
|
__typename?: 'UpdateTaskChecklistItemLocationPayload';
|
|
|
|
checklistID: Scalars['UUID'];
|
|
|
|
prevChecklistID: Scalars['UUID'];
|
|
|
|
checklistItem: TaskChecklistItem;
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistLocation = {
|
|
|
|
checklistID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistLocationPayload = {
|
|
|
|
__typename?: 'UpdateTaskChecklistLocationPayload';
|
|
|
|
checklist: TaskChecklist;
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateTaskChecklist = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
2020-05-31 06:11:19 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskChecklistItemPayload = {
|
|
|
|
__typename?: 'DeleteTaskChecklistItemPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
taskChecklistItem: TaskChecklistItem;
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateTaskChecklistItem = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetTaskChecklistItemComplete = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
complete: Scalars['Boolean'];
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskChecklistItem = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
};
|
2020-06-23 22:20:53 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskChecklistItemName = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
2020-06-23 22:20:53 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskChecklistName = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
2020-06-23 22:20:53 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskChecklist = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskChecklistPayload = {
|
|
|
|
__typename?: 'DeleteTaskChecklistPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
taskChecklist: TaskChecklist;
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewTaskGroupLocation = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTaskGroupName = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskGroupInput = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTaskGroupPayload = {
|
|
|
|
__typename?: 'DeleteTaskGroupPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
affectedRows: Scalars['Int'];
|
|
|
|
taskGroup: TaskGroup;
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewTaskGroup = {
|
|
|
|
projectID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type AddTaskLabelInput = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type RemoveTaskLabelInput = {
|
|
|
|
taskLabelID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type ToggleTaskLabelInput = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type ToggleTaskLabelPayload = {
|
|
|
|
__typename?: 'ToggleTaskLabelPayload';
|
|
|
|
active: Scalars['Boolean'];
|
|
|
|
task: Task;
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewTeam = {
|
|
|
|
name: Scalars['String'];
|
|
|
|
organizationID: Scalars['UUID'];
|
|
|
|
};
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTeam = {
|
|
|
|
teamID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTeamPayload = {
|
|
|
|
__typename?: 'DeleteTeamPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
team: Team;
|
|
|
|
projects: Array<Project>;
|
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTeamMember = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-07-12 09:06:11 +02:00
|
|
|
newOwnerID?: Maybe<Scalars['UUID']>;
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTeamMemberPayload = {
|
|
|
|
__typename?: 'DeleteTeamMemberPayload';
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-07-12 09:06:11 +02:00
|
|
|
affectedProjects: Array<Project>;
|
2020-07-05 01:02:57 +02:00
|
|
|
};
|
2020-04-11 04:22:58 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateTeamMember = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
teamID: Scalars['UUID'];
|
2020-06-19 01:12:15 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateTeamMemberPayload = {
|
|
|
|
__typename?: 'CreateTeamMemberPayload';
|
|
|
|
team: Team;
|
|
|
|
teamMember: Member;
|
|
|
|
};
|
2020-06-19 01:12:15 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTeamMemberRole = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
roleCode: RoleCode;
|
2020-06-16 00:36:59 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type UpdateTeamMemberRolePayload = {
|
|
|
|
__typename?: 'UpdateTeamMemberRolePayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
member: Member;
|
|
|
|
};
|
2020-06-16 00:36:59 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetTeamOwner = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type SetTeamOwnerPayload = {
|
|
|
|
__typename?: 'SetTeamOwnerPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
prevOwner: Member;
|
|
|
|
newOwner: Member;
|
|
|
|
};
|
2020-04-11 21:24:45 +02:00
|
|
|
|
2020-07-17 02:40:23 +02:00
|
|
|
export type UpdateUserPassword = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
password: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateUserPasswordPayload = {
|
|
|
|
__typename?: 'UpdateUserPasswordPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
user: UserAccount;
|
|
|
|
};
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type UpdateUserRole = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
roleCode: RoleCode;
|
|
|
|
};
|
|
|
|
|
|
|
|
export type UpdateUserRolePayload = {
|
|
|
|
__typename?: 'UpdateUserRolePayload';
|
|
|
|
user: UserAccount;
|
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewRefreshToken = {
|
|
|
|
userId: Scalars['String'];
|
2020-04-20 05:02:55 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type NewUserAccount = {
|
|
|
|
username: Scalars['String'];
|
|
|
|
email: Scalars['String'];
|
|
|
|
fullName: Scalars['String'];
|
|
|
|
initials: Scalars['String'];
|
|
|
|
password: Scalars['String'];
|
|
|
|
roleCode: Scalars['String'];
|
|
|
|
};
|
2020-04-20 05:02:55 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type LogoutUser = {
|
|
|
|
userID: Scalars['String'];
|
2020-04-21 01:04:27 +02:00
|
|
|
};
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteUserAccount = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
2020-04-21 01:04:27 +02:00
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteUserAccountPayload = {
|
|
|
|
__typename?: 'DeleteUserAccountPayload';
|
|
|
|
ok: Scalars['Boolean'];
|
|
|
|
userAccount: UserAccount;
|
2020-04-11 21:24:45 +02:00
|
|
|
};
|
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type AssignTaskMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type AssignTaskMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { assignTask: (
|
|
|
|
{ __typename?: 'Task' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Task, 'id'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { assigned: Array<(
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName'>
|
2020-04-20 05:02:55 +02:00
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-13 00:21:58 +02:00
|
|
|
export type ClearProfileAvatarMutationVariables = {};
|
|
|
|
|
|
|
|
|
|
|
|
export type ClearProfileAvatarMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { clearProfileAvatar: (
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id' | 'fullName'>
|
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'initials' | 'bgColor' | 'url'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-01 04:20:03 +02:00
|
|
|
export type CreateProjectMutationVariables = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateProjectMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createProject: (
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
& { team: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-05-27 02:53:31 +02:00
|
|
|
export type CreateProjectLabelMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
labelColorID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateProjectLabelMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createProjectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
2020-05-27 23:18:50 +02:00
|
|
|
& Pick<ProjectLabel, 'id' | 'createdDate' | 'name'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
2020-05-28 03:12:50 +02:00
|
|
|
& Pick<LabelColor, 'id' | 'colorHex' | 'name' | 'position'>
|
2020-05-27 23:18:50 +02:00
|
|
|
) }
|
2020-05-27 02:53:31 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
export type CreateTaskGroupMutationVariables = {
|
|
|
|
projectID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
2020-04-10 21:47:24 +02:00
|
|
|
};
|
2020-04-10 05:27:57 +02:00
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type CreateTaskGroupMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTaskGroup: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<TaskGroup, 'id' | 'name' | 'position'>
|
2020-04-11 04:22:58 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-05-28 03:12:50 +02:00
|
|
|
export type DeleteProjectLabelMutationVariables = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteProjectLabelMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteProjectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
|
|
|
& Pick<ProjectLabel, 'id'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type DeleteTaskMutationVariables = {
|
|
|
|
taskID: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type DeleteTaskMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTask: (
|
|
|
|
{ __typename?: 'DeleteTaskPayload' }
|
|
|
|
& Pick<DeleteTaskPayload, 'taskID'>
|
|
|
|
) }
|
|
|
|
);
|
2020-04-10 05:27:57 +02:00
|
|
|
|
2020-04-11 21:24:45 +02:00
|
|
|
export type DeleteTaskGroupMutationVariables = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteTaskGroupMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTaskGroup: (
|
|
|
|
{ __typename?: 'DeleteTaskGroupPayload' }
|
|
|
|
& Pick<DeleteTaskGroupPayload, 'ok' | 'affectedRows'>
|
|
|
|
& { taskGroup: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<TaskGroup, 'id'>
|
2020-04-11 21:24:45 +02:00
|
|
|
& { tasks: Array<(
|
|
|
|
{ __typename?: 'Task' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Task, 'id' | 'name'>
|
2020-04-11 21:24:45 +02:00
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type FindProjectQueryVariables = {
|
|
|
|
projectId: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type FindProjectQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
|
|
|
& { findProject: (
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'name'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { members: Array<(
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName' | 'username'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
), profileIcon: (
|
2020-04-20 05:02:55 +02:00
|
|
|
{ __typename?: 'ProfileIcon' }
|
2020-04-21 01:04:27 +02:00
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-04-20 05:02:55 +02:00
|
|
|
) }
|
2020-05-27 02:53:31 +02:00
|
|
|
)>, labels: Array<(
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
2020-05-27 23:18:50 +02:00
|
|
|
& Pick<ProjectLabel, 'id' | 'createdDate' | 'name'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'name' | 'colorHex' | 'position'>
|
|
|
|
) }
|
2020-04-20 05:02:55 +02:00
|
|
|
)>, taskGroups: Array<(
|
2020-04-11 04:22:58 +02:00
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<TaskGroup, 'id' | 'name' | 'position'>
|
2020-04-11 04:22:58 +02:00
|
|
|
& { tasks: Array<(
|
|
|
|
{ __typename?: 'Task' }
|
2020-06-19 01:12:15 +02:00
|
|
|
& TaskFieldsFragment
|
2020-04-11 04:22:58 +02:00
|
|
|
)> }
|
|
|
|
)> }
|
2020-05-27 23:18:50 +02:00
|
|
|
), labelColors: Array<(
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'position' | 'colorHex' | 'name'>
|
2020-07-05 01:02:57 +02:00
|
|
|
)>, users: Array<(
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id' | 'email' | 'fullName' | 'username'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
), profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-07-18 02:40:05 +02:00
|
|
|
), owned: (
|
|
|
|
{ __typename?: 'OwnedList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
|
|
|
), member: (
|
|
|
|
{ __typename?: 'MemberList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
2020-07-05 01:02:57 +02:00
|
|
|
) }
|
2020-05-27 23:18:50 +02:00
|
|
|
)> }
|
2020-04-11 04:22:58 +02:00
|
|
|
);
|
2020-04-10 05:27:57 +02:00
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type FindTaskQueryVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type FindTaskQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
|
|
|
& { findTask: (
|
|
|
|
{ __typename?: 'Task' }
|
2020-06-19 23:33:02 +02:00
|
|
|
& Pick<Task, 'id' | 'name' | 'description' | 'dueDate' | 'position' | 'complete'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { taskGroup: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<TaskGroup, 'id'>
|
2020-06-23 22:20:53 +02:00
|
|
|
), badges: (
|
|
|
|
{ __typename?: 'TaskBadges' }
|
|
|
|
& { checklist?: Maybe<(
|
|
|
|
{ __typename?: 'ChecklistBadge' }
|
|
|
|
& Pick<ChecklistBadge, 'total' | 'complete'>
|
|
|
|
)> }
|
2020-06-19 01:12:15 +02:00
|
|
|
), checklists: Array<(
|
|
|
|
{ __typename?: 'TaskChecklist' }
|
|
|
|
& Pick<TaskChecklist, 'id' | 'name' | 'position'>
|
|
|
|
& { items: Array<(
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'name' | 'taskChecklistID' | 'complete' | 'position'>
|
|
|
|
)> }
|
|
|
|
)>, labels: Array<(
|
2020-05-31 06:11:19 +02:00
|
|
|
{ __typename?: 'TaskLabel' }
|
|
|
|
& Pick<TaskLabel, 'id' | 'assignedDate'>
|
|
|
|
& { projectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
|
|
|
& Pick<ProjectLabel, 'id' | 'name' | 'createdDate'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'colorHex' | 'position' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
)>, assigned: Array<(
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
2020-04-21 01:04:27 +02:00
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-04-20 05:02:55 +02:00
|
|
|
) }
|
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export type TaskFieldsFragment = (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& Pick<Task, 'id' | 'name' | 'description' | 'dueDate' | 'complete' | 'position'>
|
2020-06-23 22:20:53 +02:00
|
|
|
& { badges: (
|
|
|
|
{ __typename?: 'TaskBadges' }
|
|
|
|
& { checklist?: Maybe<(
|
|
|
|
{ __typename?: 'ChecklistBadge' }
|
|
|
|
& Pick<ChecklistBadge, 'complete' | 'total'>
|
|
|
|
)> }
|
|
|
|
), taskGroup: (
|
2020-06-19 01:12:15 +02:00
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-06-23 22:20:53 +02:00
|
|
|
& Pick<TaskGroup, 'id' | 'name' | 'position'>
|
2020-06-19 01:12:15 +02:00
|
|
|
), labels: Array<(
|
|
|
|
{ __typename?: 'TaskLabel' }
|
|
|
|
& Pick<TaskLabel, 'id' | 'assignedDate'>
|
|
|
|
& { projectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
|
|
|
& Pick<ProjectLabel, 'id' | 'name' | 'createdDate'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'colorHex' | 'position' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
)>, assigned: Array<(
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName'>
|
2020-06-19 01:12:15 +02:00
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
|
|
|
) }
|
|
|
|
)> }
|
|
|
|
);
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type GetProjectsQueryVariables = {};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type GetProjectsQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
2020-06-21 00:49:11 +02:00
|
|
|
& { organizations: Array<(
|
|
|
|
{ __typename?: 'Organization' }
|
|
|
|
& Pick<Organization, 'id' | 'name'>
|
|
|
|
)>, teams: Array<(
|
2020-06-01 04:20:03 +02:00
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name' | 'createdAt'>
|
|
|
|
)>, projects: Array<(
|
2020-04-20 05:02:55 +02:00
|
|
|
{ __typename?: 'Project' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Project, 'id' | 'name'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { team: (
|
2020-04-11 04:22:58 +02:00
|
|
|
{ __typename?: 'Team' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Team, 'id' | 'name'>
|
2020-04-20 05:02:55 +02:00
|
|
|
) }
|
2020-04-11 04:22:58 +02:00
|
|
|
)> }
|
|
|
|
);
|
2020-04-10 05:27:57 +02:00
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type MeQueryVariables = {};
|
|
|
|
|
|
|
|
|
|
|
|
export type MeQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
|
|
|
& { me: (
|
|
|
|
{ __typename?: 'UserAccount' }
|
2020-06-13 00:21:58 +02:00
|
|
|
& Pick<UserAccount, 'id' | 'fullName'>
|
2020-04-20 05:02:55 +02:00
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
2020-06-13 00:21:58 +02:00
|
|
|
& Pick<ProfileIcon, 'initials' | 'bgColor' | 'url'>
|
2020-04-20 05:02:55 +02:00
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateProjectMemberMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateProjectMemberMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createProjectMember: (
|
|
|
|
{ __typename?: 'CreateProjectMemberPayload' }
|
|
|
|
& Pick<CreateProjectMemberPayload, 'ok'>
|
|
|
|
& { member: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName' | 'username'>
|
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
|
|
|
), role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-21 00:49:11 +02:00
|
|
|
export type DeleteProjectMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteProjectMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteProject: (
|
|
|
|
{ __typename?: 'DeleteProjectPayload' }
|
|
|
|
& Pick<DeleteProjectPayload, 'ok'>
|
|
|
|
& { project: (
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteProjectMemberMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteProjectMemberMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteProjectMember: (
|
|
|
|
{ __typename?: 'DeleteProjectMemberPayload' }
|
|
|
|
& Pick<DeleteProjectMemberPayload, 'ok' | 'projectID'>
|
|
|
|
& { member: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type SetProjectOwnerMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
ownerID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type SetProjectOwnerMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { setProjectOwner: (
|
|
|
|
{ __typename?: 'SetProjectOwnerPayload' }
|
|
|
|
& Pick<SetProjectOwnerPayload, 'ok'>
|
|
|
|
& { newOwner: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
), prevOwner: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type UpdateProjectMemberRoleMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
roleCode: RoleCode;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateProjectMemberRoleMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateProjectMemberRole: (
|
|
|
|
{ __typename?: 'UpdateProjectMemberRolePayload' }
|
|
|
|
& Pick<UpdateProjectMemberRolePayload, 'ok'>
|
|
|
|
& { member: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type CreateTaskMutationVariables = {
|
|
|
|
taskGroupID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateTaskMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTask: (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& TaskFieldsFragment
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type CreateTaskChecklistMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateTaskChecklistMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTaskChecklist: (
|
|
|
|
{ __typename?: 'TaskChecklist' }
|
|
|
|
& Pick<TaskChecklist, 'id' | 'name' | 'position'>
|
|
|
|
& { items: Array<(
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'name' | 'taskChecklistID' | 'complete' | 'position'>
|
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export type CreateTaskChecklistItemMutationVariables = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateTaskChecklistItemMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTaskChecklistItem: (
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'name' | 'taskChecklistID' | 'position' | 'complete'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type DeleteTaskChecklistMutationVariables = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteTaskChecklistMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTaskChecklist: (
|
|
|
|
{ __typename?: 'DeleteTaskChecklistPayload' }
|
|
|
|
& Pick<DeleteTaskChecklistPayload, 'ok'>
|
|
|
|
& { taskChecklist: (
|
|
|
|
{ __typename?: 'TaskChecklist' }
|
|
|
|
& Pick<TaskChecklist, 'id'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export type DeleteTaskChecklistItemMutationVariables = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteTaskChecklistItemMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTaskChecklistItem: (
|
|
|
|
{ __typename?: 'DeleteTaskChecklistItemPayload' }
|
|
|
|
& Pick<DeleteTaskChecklistItemPayload, 'ok'>
|
|
|
|
& { taskChecklistItem: (
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'taskChecklistID'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type SetTaskChecklistItemCompleteMutationVariables = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
complete: Scalars['Boolean'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type SetTaskChecklistItemCompleteMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { setTaskChecklistItemComplete: (
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
2020-06-23 22:20:53 +02:00
|
|
|
& Pick<TaskChecklistItem, 'id' | 'complete'>
|
2020-06-19 01:12:15 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type SetTaskCompleteMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
complete: Scalars['Boolean'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type SetTaskCompleteMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { setTaskComplete: (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& TaskFieldsFragment
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type UpdateTaskChecklistItemLocationMutationVariables = {
|
|
|
|
checklistID: Scalars['UUID'];
|
|
|
|
checklistItemID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistItemLocationMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskChecklistItemLocation: (
|
|
|
|
{ __typename?: 'UpdateTaskChecklistItemLocationPayload' }
|
|
|
|
& Pick<UpdateTaskChecklistItemLocationPayload, 'checklistID' | 'prevChecklistID'>
|
|
|
|
& { checklistItem: (
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'taskChecklistID' | 'position'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export type UpdateTaskChecklistItemNameMutationVariables = {
|
|
|
|
taskChecklistItemID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistItemNameMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskChecklistItemName: (
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'name'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type UpdateTaskChecklistLocationMutationVariables = {
|
|
|
|
checklistID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistLocationMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskChecklistLocation: (
|
|
|
|
{ __typename?: 'UpdateTaskChecklistLocationPayload' }
|
|
|
|
& { checklist: (
|
|
|
|
{ __typename?: 'TaskChecklist' }
|
|
|
|
& Pick<TaskChecklist, 'id' | 'position'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type UpdateTaskChecklistNameMutationVariables = {
|
|
|
|
taskChecklistID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskChecklistNameMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskChecklistName: (
|
|
|
|
{ __typename?: 'TaskChecklist' }
|
|
|
|
& Pick<TaskChecklist, 'id' | 'name' | 'position'>
|
|
|
|
& { items: Array<(
|
|
|
|
{ __typename?: 'TaskChecklistItem' }
|
|
|
|
& Pick<TaskChecklistItem, 'id' | 'name' | 'taskChecklistID' | 'complete' | 'position'>
|
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export type UpdateTaskGroupNameMutationVariables = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskGroupNameMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskGroupName: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
|
|
|
& Pick<TaskGroup, 'id' | 'name'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-21 00:49:11 +02:00
|
|
|
export type CreateTeamMutationVariables = {
|
|
|
|
name: Scalars['String'];
|
|
|
|
organizationID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateTeamMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTeam: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'createdAt' | 'name'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type CreateTeamMemberMutationVariables = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateTeamMemberMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createTeamMember: (
|
|
|
|
{ __typename?: 'CreateTeamMemberPayload' }
|
|
|
|
& { team: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id'>
|
|
|
|
), teamMember: (
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'username' | 'fullName'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
), profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type DeleteTeamMutationVariables = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteTeamMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTeam: (
|
|
|
|
{ __typename?: 'DeleteTeamPayload' }
|
|
|
|
& Pick<DeleteTeamPayload, 'ok'>
|
|
|
|
& { team: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-05 01:02:57 +02:00
|
|
|
export type DeleteTeamMemberMutationVariables = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
2020-07-12 09:06:11 +02:00
|
|
|
newOwnerID?: Maybe<Scalars['UUID']>;
|
2020-07-05 01:02:57 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteTeamMemberMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteTeamMember: (
|
|
|
|
{ __typename?: 'DeleteTeamMemberPayload' }
|
|
|
|
& Pick<DeleteTeamMemberPayload, 'teamID' | 'userID'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type GetTeamQueryVariables = {
|
|
|
|
teamID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type GetTeamQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
|
|
|
& { findTeam: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'createdAt' | 'name'>
|
2020-07-05 01:02:57 +02:00
|
|
|
& { members: Array<(
|
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName' | 'username'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
2020-07-18 02:40:05 +02:00
|
|
|
), profileIcon: (
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-07-18 02:40:05 +02:00
|
|
|
), owned: (
|
|
|
|
{ __typename?: 'OwnedList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
|
|
|
), member: (
|
|
|
|
{ __typename?: 'MemberList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
2020-07-05 01:02:57 +02:00
|
|
|
) }
|
|
|
|
)> }
|
2020-06-23 22:20:53 +02:00
|
|
|
), projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
& { team: (
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
) }
|
2020-07-05 01:02:57 +02:00
|
|
|
)>, users: Array<(
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id' | 'email' | 'fullName' | 'username'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
), profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-07-18 02:40:05 +02:00
|
|
|
), owned: (
|
|
|
|
{ __typename?: 'OwnedList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
|
|
|
), member: (
|
|
|
|
{ __typename?: 'MemberList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
2020-07-05 01:02:57 +02:00
|
|
|
) }
|
2020-06-23 22:20:53 +02:00
|
|
|
)> }
|
|
|
|
);
|
|
|
|
|
2020-05-31 06:11:19 +02:00
|
|
|
export type ToggleTaskLabelMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type ToggleTaskLabelMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { toggleTaskLabel: (
|
|
|
|
{ __typename?: 'ToggleTaskLabelPayload' }
|
|
|
|
& Pick<ToggleTaskLabelPayload, 'active'>
|
|
|
|
& { task: (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& Pick<Task, 'id'>
|
|
|
|
& { labels: Array<(
|
|
|
|
{ __typename?: 'TaskLabel' }
|
|
|
|
& Pick<TaskLabel, 'id' | 'assignedDate'>
|
|
|
|
& { projectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
|
|
|
& Pick<ProjectLabel, 'id' | 'createdDate' | 'name'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'colorHex' | 'name' | 'position'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-21 01:04:27 +02:00
|
|
|
export type UnassignTaskMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UnassignTaskMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { unassignTask: (
|
|
|
|
{ __typename?: 'Task' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Task, 'id'>
|
2020-04-21 01:04:27 +02:00
|
|
|
& { assigned: Array<(
|
2020-07-05 01:02:57 +02:00
|
|
|
{ __typename?: 'Member' }
|
|
|
|
& Pick<Member, 'id' | 'fullName'>
|
2020-04-21 01:04:27 +02:00
|
|
|
)> }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-05-28 03:12:50 +02:00
|
|
|
export type UpdateProjectLabelMutationVariables = {
|
|
|
|
projectLabelID: Scalars['UUID'];
|
|
|
|
labelColorID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateProjectLabelMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateProjectLabel: (
|
|
|
|
{ __typename?: 'ProjectLabel' }
|
|
|
|
& Pick<ProjectLabel, 'id' | 'createdDate' | 'name'>
|
|
|
|
& { labelColor: (
|
|
|
|
{ __typename?: 'LabelColor' }
|
|
|
|
& Pick<LabelColor, 'id' | 'colorHex' | 'name' | 'position'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-05-31 06:11:19 +02:00
|
|
|
export type UpdateProjectNameMutationVariables = {
|
|
|
|
projectID: Scalars['UUID'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateProjectNameMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateProjectName: (
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-20 05:02:55 +02:00
|
|
|
export type UpdateTaskDescriptionMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
description: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskDescriptionMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskDescription: (
|
|
|
|
{ __typename?: 'Task' }
|
2020-06-13 00:21:58 +02:00
|
|
|
& Pick<Task, 'id' | 'description'>
|
2020-04-20 05:02:55 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-16 00:36:59 +02:00
|
|
|
export type UpdateTaskDueDateMutationVariables = {
|
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
dueDate?: Maybe<Scalars['Time']>;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskDueDateMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskDueDate: (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& Pick<Task, 'id' | 'dueDate'>
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-11 04:53:03 +02:00
|
|
|
export type UpdateTaskGroupLocationMutationVariables = {
|
|
|
|
taskGroupID: Scalars['UUID'];
|
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateTaskGroupLocationMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskGroupLocation: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<TaskGroup, 'id' | 'position'>
|
2020-04-11 04:53:03 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-04-10 05:27:57 +02:00
|
|
|
export type UpdateTaskLocationMutationVariables = {
|
2020-06-01 04:20:03 +02:00
|
|
|
taskID: Scalars['UUID'];
|
|
|
|
taskGroupID: Scalars['UUID'];
|
2020-04-10 05:27:57 +02:00
|
|
|
position: Scalars['Float'];
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type UpdateTaskLocationMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskLocation: (
|
2020-06-01 04:20:03 +02:00
|
|
|
{ __typename?: 'UpdateTaskLocationPayload' }
|
|
|
|
& Pick<UpdateTaskLocationPayload, 'previousTaskGroupID'>
|
|
|
|
& { task: (
|
|
|
|
{ __typename?: 'Task' }
|
|
|
|
& Pick<Task, 'id' | 'createdAt' | 'name' | 'position'>
|
|
|
|
& { taskGroup: (
|
|
|
|
{ __typename?: 'TaskGroup' }
|
|
|
|
& Pick<TaskGroup, 'id'>
|
|
|
|
) }
|
|
|
|
) }
|
2020-04-11 04:22:58 +02:00
|
|
|
) }
|
|
|
|
);
|
2020-04-10 05:27:57 +02:00
|
|
|
|
|
|
|
export type UpdateTaskNameMutationVariables = {
|
|
|
|
taskID: Scalars['String'];
|
|
|
|
name: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
2020-04-11 04:22:58 +02:00
|
|
|
|
|
|
|
export type UpdateTaskNameMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateTaskName: (
|
|
|
|
{ __typename?: 'Task' }
|
2020-05-27 02:53:31 +02:00
|
|
|
& Pick<Task, 'id' | 'name' | 'position'>
|
2020-04-11 04:22:58 +02:00
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type CreateUserAccountMutationVariables = {
|
|
|
|
username: Scalars['String'];
|
2020-07-05 01:02:57 +02:00
|
|
|
roleCode: Scalars['String'];
|
2020-06-23 22:20:53 +02:00
|
|
|
email: Scalars['String'];
|
|
|
|
fullName: Scalars['String'];
|
|
|
|
initials: Scalars['String'];
|
|
|
|
password: Scalars['String'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type CreateUserAccountMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { createUserAccount: (
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id' | 'email' | 'fullName' | 'initials' | 'username'>
|
|
|
|
& { profileIcon: (
|
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-07-05 01:02:57 +02:00
|
|
|
), role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
|
|
|
export type DeleteUserAccountMutationVariables = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type DeleteUserAccountMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { deleteUserAccount: (
|
|
|
|
{ __typename?: 'DeleteUserAccountPayload' }
|
|
|
|
& Pick<DeleteUserAccountPayload, 'ok'>
|
|
|
|
& { userAccount: (
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id'>
|
2020-06-23 22:20:53 +02:00
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-07-12 09:06:11 +02:00
|
|
|
export type UpdateUserRoleMutationVariables = {
|
|
|
|
userID: Scalars['UUID'];
|
|
|
|
roleCode: RoleCode;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
export type UpdateUserRoleMutation = (
|
|
|
|
{ __typename?: 'Mutation' }
|
|
|
|
& { updateUserRole: (
|
|
|
|
{ __typename?: 'UpdateUserRolePayload' }
|
|
|
|
& { user: (
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id'>
|
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
) }
|
|
|
|
);
|
|
|
|
|
2020-06-23 22:20:53 +02:00
|
|
|
export type UsersQueryVariables = {};
|
|
|
|
|
|
|
|
|
|
|
|
export type UsersQuery = (
|
|
|
|
{ __typename?: 'Query' }
|
|
|
|
& { users: Array<(
|
|
|
|
{ __typename?: 'UserAccount' }
|
|
|
|
& Pick<UserAccount, 'id' | 'email' | 'fullName' | 'username'>
|
2020-07-05 01:02:57 +02:00
|
|
|
& { role: (
|
|
|
|
{ __typename?: 'Role' }
|
|
|
|
& Pick<Role, 'code' | 'name'>
|
|
|
|
), profileIcon: (
|
2020-06-23 22:20:53 +02:00
|
|
|
{ __typename?: 'ProfileIcon' }
|
|
|
|
& Pick<ProfileIcon, 'url' | 'initials' | 'bgColor'>
|
2020-07-18 02:40:05 +02:00
|
|
|
), owned: (
|
|
|
|
{ __typename?: 'OwnedList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
|
|
|
), member: (
|
|
|
|
{ __typename?: 'MemberList' }
|
|
|
|
& { teams: Array<(
|
|
|
|
{ __typename?: 'Team' }
|
|
|
|
& Pick<Team, 'id' | 'name'>
|
|
|
|
)>, projects: Array<(
|
|
|
|
{ __typename?: 'Project' }
|
|
|
|
& Pick<Project, 'id' | 'name'>
|
|
|
|
)> }
|
2020-06-23 22:20:53 +02:00
|
|
|
) }
|
|
|
|
)> }
|
|
|
|
);
|
|
|
|
|
2020-06-19 01:12:15 +02:00
|
|
|
export const TaskFieldsFragmentDoc = gql`
|
|
|
|
fragment TaskFields on Task {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
description
|
|
|
|
dueDate
|
|
|
|
complete
|
|
|
|
position
|
2020-06-23 22:20:53 +02:00
|
|
|
badges {
|
|
|
|
checklist {
|
|
|
|
complete
|
|
|
|
total
|
|
|
|
}
|
|
|
|
}
|
2020-06-19 01:12:15 +02:00
|
|
|
taskGroup {
|
|
|
|
id
|
2020-06-23 22:20:53 +02:00
|
|
|
name
|
|
|
|
position
|
2020-06-19 01:12:15 +02:00
|
|
|
}
|
|
|
|
labels {
|
|
|
|
id
|
|
|
|
assignedDate
|
|
|
|
projectLabel {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
createdDate
|
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
colorHex
|
|
|
|
position
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assigned {
|
|
|
|
id
|
|
|
|
fullName
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
2020-04-20 05:02:55 +02:00
|
|
|
export const AssignTaskDocument = gql`
|
|
|
|
mutation assignTask($taskID: UUID!, $userID: UUID!) {
|
|
|
|
assignTask(input: {taskID: $taskID, userID: $userID}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-20 05:02:55 +02:00
|
|
|
assigned {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type AssignTaskMutationFn = ApolloReactCommon.MutationFunction<AssignTaskMutation, AssignTaskMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useAssignTaskMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useAssignTaskMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useAssignTaskMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [assignTaskMutation, { data, loading, error }] = useAssignTaskMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useAssignTaskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<AssignTaskMutation, AssignTaskMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<AssignTaskMutation, AssignTaskMutationVariables>(AssignTaskDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type AssignTaskMutationHookResult = ReturnType<typeof useAssignTaskMutation>;
|
|
|
|
export type AssignTaskMutationResult = ApolloReactCommon.MutationResult<AssignTaskMutation>;
|
|
|
|
export type AssignTaskMutationOptions = ApolloReactCommon.BaseMutationOptions<AssignTaskMutation, AssignTaskMutationVariables>;
|
2020-06-13 00:21:58 +02:00
|
|
|
export const ClearProfileAvatarDocument = gql`
|
|
|
|
mutation clearProfileAvatar {
|
|
|
|
clearProfileAvatar {
|
|
|
|
id
|
|
|
|
fullName
|
|
|
|
profileIcon {
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
url
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type ClearProfileAvatarMutationFn = ApolloReactCommon.MutationFunction<ClearProfileAvatarMutation, ClearProfileAvatarMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useClearProfileAvatarMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useClearProfileAvatarMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useClearProfileAvatarMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [clearProfileAvatarMutation, { data, loading, error }] = useClearProfileAvatarMutation({
|
|
|
|
* variables: {
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useClearProfileAvatarMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<ClearProfileAvatarMutation, ClearProfileAvatarMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<ClearProfileAvatarMutation, ClearProfileAvatarMutationVariables>(ClearProfileAvatarDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type ClearProfileAvatarMutationHookResult = ReturnType<typeof useClearProfileAvatarMutation>;
|
|
|
|
export type ClearProfileAvatarMutationResult = ApolloReactCommon.MutationResult<ClearProfileAvatarMutation>;
|
|
|
|
export type ClearProfileAvatarMutationOptions = ApolloReactCommon.BaseMutationOptions<ClearProfileAvatarMutation, ClearProfileAvatarMutationVariables>;
|
2020-06-01 04:20:03 +02:00
|
|
|
export const CreateProjectDocument = gql`
|
|
|
|
mutation createProject($teamID: UUID!, $userID: UUID!, $name: String!) {
|
|
|
|
createProject(input: {teamID: $teamID, userID: $userID, name: $name}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
team {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateProjectMutationFn = ApolloReactCommon.MutationFunction<CreateProjectMutation, CreateProjectMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateProjectMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateProjectMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateProjectMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createProjectMutation, { data, loading, error }] = useCreateProjectMutation({
|
|
|
|
* variables: {
|
|
|
|
* teamID: // value for 'teamID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateProjectMutation, CreateProjectMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateProjectMutation, CreateProjectMutationVariables>(CreateProjectDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateProjectMutationHookResult = ReturnType<typeof useCreateProjectMutation>;
|
|
|
|
export type CreateProjectMutationResult = ApolloReactCommon.MutationResult<CreateProjectMutation>;
|
|
|
|
export type CreateProjectMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateProjectMutation, CreateProjectMutationVariables>;
|
2020-05-27 02:53:31 +02:00
|
|
|
export const CreateProjectLabelDocument = gql`
|
|
|
|
mutation createProjectLabel($projectID: UUID!, $labelColorID: UUID!, $name: String!) {
|
|
|
|
createProjectLabel(input: {projectID: $projectID, labelColorID: $labelColorID, name: $name}) {
|
|
|
|
id
|
|
|
|
createdDate
|
2020-05-27 23:18:50 +02:00
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
colorHex
|
2020-05-28 03:12:50 +02:00
|
|
|
name
|
|
|
|
position
|
2020-05-27 23:18:50 +02:00
|
|
|
}
|
2020-05-27 02:53:31 +02:00
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateProjectLabelMutationFn = ApolloReactCommon.MutationFunction<CreateProjectLabelMutation, CreateProjectLabelMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateProjectLabelMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateProjectLabelMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateProjectLabelMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createProjectLabelMutation, { data, loading, error }] = useCreateProjectLabelMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* labelColorID: // value for 'labelColorID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateProjectLabelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateProjectLabelMutation, CreateProjectLabelMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateProjectLabelMutation, CreateProjectLabelMutationVariables>(CreateProjectLabelDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateProjectLabelMutationHookResult = ReturnType<typeof useCreateProjectLabelMutation>;
|
|
|
|
export type CreateProjectLabelMutationResult = ApolloReactCommon.MutationResult<CreateProjectLabelMutation>;
|
|
|
|
export type CreateProjectLabelMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateProjectLabelMutation, CreateProjectLabelMutationVariables>;
|
2020-04-11 04:22:58 +02:00
|
|
|
export const CreateTaskGroupDocument = gql`
|
|
|
|
mutation createTaskGroup($projectID: String!, $name: String!, $position: Float!) {
|
|
|
|
createTaskGroup(input: {projectID: $projectID, name: $name, position: $position}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 04:22:58 +02:00
|
|
|
name
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateTaskGroupMutationFn = ApolloReactCommon.MutationFunction<CreateTaskGroupMutation, CreateTaskGroupMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTaskGroupMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTaskGroupMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTaskGroupMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTaskGroupMutation, { data, loading, error }] = useCreateTaskGroupMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTaskGroupMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTaskGroupMutation, CreateTaskGroupMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTaskGroupMutation, CreateTaskGroupMutationVariables>(CreateTaskGroupDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTaskGroupMutationHookResult = ReturnType<typeof useCreateTaskGroupMutation>;
|
|
|
|
export type CreateTaskGroupMutationResult = ApolloReactCommon.MutationResult<CreateTaskGroupMutation>;
|
|
|
|
export type CreateTaskGroupMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTaskGroupMutation, CreateTaskGroupMutationVariables>;
|
2020-05-28 03:12:50 +02:00
|
|
|
export const DeleteProjectLabelDocument = gql`
|
|
|
|
mutation deleteProjectLabel($projectLabelID: UUID!) {
|
|
|
|
deleteProjectLabel(input: {projectLabelID: $projectLabelID}) {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteProjectLabelMutationFn = ApolloReactCommon.MutationFunction<DeleteProjectLabelMutation, DeleteProjectLabelMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteProjectLabelMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteProjectLabelMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteProjectLabelMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteProjectLabelMutation, { data, loading, error }] = useDeleteProjectLabelMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectLabelID: // value for 'projectLabelID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteProjectLabelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteProjectLabelMutation, DeleteProjectLabelMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteProjectLabelMutation, DeleteProjectLabelMutationVariables>(DeleteProjectLabelDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteProjectLabelMutationHookResult = ReturnType<typeof useDeleteProjectLabelMutation>;
|
|
|
|
export type DeleteProjectLabelMutationResult = ApolloReactCommon.MutationResult<DeleteProjectLabelMutation>;
|
|
|
|
export type DeleteProjectLabelMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteProjectLabelMutation, DeleteProjectLabelMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
export const DeleteTaskDocument = gql`
|
2020-04-11 04:22:58 +02:00
|
|
|
mutation deleteTask($taskID: String!) {
|
|
|
|
deleteTask(input: {taskID: $taskID}) {
|
|
|
|
taskID
|
2020-04-10 05:27:57 +02:00
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
}
|
|
|
|
`;
|
2020-04-10 05:27:57 +02:00
|
|
|
export type DeleteTaskMutationFn = ApolloReactCommon.MutationFunction<DeleteTaskMutation, DeleteTaskMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTaskMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTaskMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTaskMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTaskMutation, { data, loading, error }] = useDeleteTaskMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
2020-04-11 04:22:58 +02:00
|
|
|
export function useDeleteTaskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTaskMutation, DeleteTaskMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTaskMutation, DeleteTaskMutationVariables>(DeleteTaskDocument, baseOptions);
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
export type DeleteTaskMutationHookResult = ReturnType<typeof useDeleteTaskMutation>;
|
|
|
|
export type DeleteTaskMutationResult = ApolloReactCommon.MutationResult<DeleteTaskMutation>;
|
2020-04-11 04:22:58 +02:00
|
|
|
export type DeleteTaskMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTaskMutation, DeleteTaskMutationVariables>;
|
2020-04-11 21:24:45 +02:00
|
|
|
export const DeleteTaskGroupDocument = gql`
|
|
|
|
mutation deleteTaskGroup($taskGroupID: UUID!) {
|
|
|
|
deleteTaskGroup(input: {taskGroupID: $taskGroupID}) {
|
|
|
|
ok
|
|
|
|
affectedRows
|
|
|
|
taskGroup {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 21:24:45 +02:00
|
|
|
tasks {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 21:24:45 +02:00
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteTaskGroupMutationFn = ApolloReactCommon.MutationFunction<DeleteTaskGroupMutation, DeleteTaskGroupMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTaskGroupMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTaskGroupMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTaskGroupMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTaskGroupMutation, { data, loading, error }] = useDeleteTaskGroupMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskGroupID: // value for 'taskGroupID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteTaskGroupMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTaskGroupMutation, DeleteTaskGroupMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTaskGroupMutation, DeleteTaskGroupMutationVariables>(DeleteTaskGroupDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteTaskGroupMutationHookResult = ReturnType<typeof useDeleteTaskGroupMutation>;
|
|
|
|
export type DeleteTaskGroupMutationResult = ApolloReactCommon.MutationResult<DeleteTaskGroupMutation>;
|
|
|
|
export type DeleteTaskGroupMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTaskGroupMutation, DeleteTaskGroupMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
export const FindProjectDocument = gql`
|
2020-04-11 04:22:58 +02:00
|
|
|
query findProject($projectId: String!) {
|
|
|
|
findProject(input: {projectId: $projectId}) {
|
|
|
|
name
|
2020-04-20 05:02:55 +02:00
|
|
|
members {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName
|
2020-07-05 01:02:57 +02:00
|
|
|
username
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
2020-04-20 05:02:55 +02:00
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
2020-04-21 01:04:27 +02:00
|
|
|
bgColor
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
2020-05-27 02:53:31 +02:00
|
|
|
labels {
|
|
|
|
id
|
|
|
|
createdDate
|
2020-05-31 06:11:19 +02:00
|
|
|
name
|
2020-05-27 23:18:50 +02:00
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
colorHex
|
|
|
|
position
|
|
|
|
}
|
2020-05-27 02:53:31 +02:00
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
taskGroups {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-10 05:27:57 +02:00
|
|
|
name
|
2020-04-11 04:22:58 +02:00
|
|
|
position
|
|
|
|
tasks {
|
2020-06-19 01:12:15 +02:00
|
|
|
...TaskFields
|
2020-04-10 05:27:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-05-27 23:18:50 +02:00
|
|
|
labelColors {
|
|
|
|
id
|
|
|
|
position
|
|
|
|
colorHex
|
|
|
|
name
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
users {
|
|
|
|
id
|
|
|
|
email
|
|
|
|
fullName
|
|
|
|
username
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
2020-07-18 02:40:05 +02:00
|
|
|
owned {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
member {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
}
|
2020-06-19 01:12:15 +02:00
|
|
|
${TaskFieldsFragmentDoc}`;
|
2020-04-10 05:27:57 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __useFindProjectQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useFindProjectQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useFindProjectQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useFindProjectQuery({
|
|
|
|
* variables: {
|
|
|
|
* projectId: // value for 'projectId'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
2020-04-11 04:22:58 +02:00
|
|
|
export function useFindProjectQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<FindProjectQuery, FindProjectQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<FindProjectQuery, FindProjectQueryVariables>(FindProjectDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useFindProjectLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<FindProjectQuery, FindProjectQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<FindProjectQuery, FindProjectQueryVariables>(FindProjectDocument, baseOptions);
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
export type FindProjectQueryHookResult = ReturnType<typeof useFindProjectQuery>;
|
|
|
|
export type FindProjectLazyQueryHookResult = ReturnType<typeof useFindProjectLazyQuery>;
|
|
|
|
export type FindProjectQueryResult = ApolloReactCommon.QueryResult<FindProjectQuery, FindProjectQueryVariables>;
|
2020-04-20 05:02:55 +02:00
|
|
|
export const FindTaskDocument = gql`
|
|
|
|
query findTask($taskID: UUID!) {
|
|
|
|
findTask(input: {taskID: $taskID}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-20 05:02:55 +02:00
|
|
|
name
|
|
|
|
description
|
2020-06-16 00:36:59 +02:00
|
|
|
dueDate
|
2020-04-20 05:02:55 +02:00
|
|
|
position
|
2020-06-19 23:33:02 +02:00
|
|
|
complete
|
2020-04-20 05:02:55 +02:00
|
|
|
taskGroup {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
badges {
|
|
|
|
checklist {
|
|
|
|
total
|
|
|
|
complete
|
|
|
|
}
|
|
|
|
}
|
2020-06-19 01:12:15 +02:00
|
|
|
checklists {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
position
|
|
|
|
items {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
taskChecklistID
|
|
|
|
complete
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
2020-05-31 06:11:19 +02:00
|
|
|
labels {
|
|
|
|
id
|
|
|
|
assignedDate
|
|
|
|
projectLabel {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
createdDate
|
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
colorHex
|
|
|
|
position
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-04-20 05:02:55 +02:00
|
|
|
assigned {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName
|
2020-04-20 05:02:55 +02:00
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
2020-04-21 01:04:27 +02:00
|
|
|
bgColor
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useFindTaskQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useFindTaskQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useFindTaskQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useFindTaskQuery({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useFindTaskQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<FindTaskQuery, FindTaskQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<FindTaskQuery, FindTaskQueryVariables>(FindTaskDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useFindTaskLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<FindTaskQuery, FindTaskQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<FindTaskQuery, FindTaskQueryVariables>(FindTaskDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type FindTaskQueryHookResult = ReturnType<typeof useFindTaskQuery>;
|
|
|
|
export type FindTaskLazyQueryHookResult = ReturnType<typeof useFindTaskLazyQuery>;
|
|
|
|
export type FindTaskQueryResult = ApolloReactCommon.QueryResult<FindTaskQuery, FindTaskQueryVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
export const GetProjectsDocument = gql`
|
2020-04-11 04:22:58 +02:00
|
|
|
query getProjects {
|
2020-06-21 00:49:11 +02:00
|
|
|
organizations {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
2020-06-01 04:20:03 +02:00
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
createdAt
|
|
|
|
}
|
2020-04-20 05:02:55 +02:00
|
|
|
projects {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 04:22:58 +02:00
|
|
|
name
|
2020-04-20 05:02:55 +02:00
|
|
|
team {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-10 05:27:57 +02:00
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
}
|
|
|
|
`;
|
2020-04-10 05:27:57 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __useGetProjectsQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useGetProjectsQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useGetProjectsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useGetProjectsQuery({
|
|
|
|
* variables: {
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
2020-04-11 04:22:58 +02:00
|
|
|
export function useGetProjectsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetProjectsQuery, GetProjectsQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<GetProjectsQuery, GetProjectsQueryVariables>(GetProjectsDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useGetProjectsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetProjectsQuery, GetProjectsQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<GetProjectsQuery, GetProjectsQueryVariables>(GetProjectsDocument, baseOptions);
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
export type GetProjectsQueryHookResult = ReturnType<typeof useGetProjectsQuery>;
|
|
|
|
export type GetProjectsLazyQueryHookResult = ReturnType<typeof useGetProjectsLazyQuery>;
|
|
|
|
export type GetProjectsQueryResult = ApolloReactCommon.QueryResult<GetProjectsQuery, GetProjectsQueryVariables>;
|
2020-04-20 05:02:55 +02:00
|
|
|
export const MeDocument = gql`
|
|
|
|
query me {
|
|
|
|
me {
|
2020-06-13 00:21:58 +02:00
|
|
|
id
|
|
|
|
fullName
|
2020-04-20 05:02:55 +02:00
|
|
|
profileIcon {
|
|
|
|
initials
|
2020-04-21 01:04:27 +02:00
|
|
|
bgColor
|
2020-06-13 00:21:58 +02:00
|
|
|
url
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useMeQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useMeQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useMeQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useMeQuery({
|
|
|
|
* variables: {
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useMeQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<MeQuery, MeQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<MeQuery, MeQueryVariables>(MeDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useMeLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<MeQuery, MeQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<MeQuery, MeQueryVariables>(MeDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type MeQueryHookResult = ReturnType<typeof useMeQuery>;
|
|
|
|
export type MeLazyQueryHookResult = ReturnType<typeof useMeLazyQuery>;
|
|
|
|
export type MeQueryResult = ApolloReactCommon.QueryResult<MeQuery, MeQueryVariables>;
|
2020-07-05 01:02:57 +02:00
|
|
|
export const CreateProjectMemberDocument = gql`
|
|
|
|
mutation createProjectMember($projectID: UUID!, $userID: UUID!) {
|
|
|
|
createProjectMember(input: {projectID: $projectID, userID: $userID}) {
|
|
|
|
ok
|
|
|
|
member {
|
|
|
|
id
|
|
|
|
fullName
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
|
|
|
username
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateProjectMemberMutationFn = ApolloReactCommon.MutationFunction<CreateProjectMemberMutation, CreateProjectMemberMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateProjectMemberMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateProjectMemberMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateProjectMemberMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createProjectMemberMutation, { data, loading, error }] = useCreateProjectMemberMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateProjectMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateProjectMemberMutation, CreateProjectMemberMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateProjectMemberMutation, CreateProjectMemberMutationVariables>(CreateProjectMemberDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateProjectMemberMutationHookResult = ReturnType<typeof useCreateProjectMemberMutation>;
|
|
|
|
export type CreateProjectMemberMutationResult = ApolloReactCommon.MutationResult<CreateProjectMemberMutation>;
|
|
|
|
export type CreateProjectMemberMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateProjectMemberMutation, CreateProjectMemberMutationVariables>;
|
2020-06-21 00:49:11 +02:00
|
|
|
export const DeleteProjectDocument = gql`
|
|
|
|
mutation deleteProject($projectID: UUID!) {
|
|
|
|
deleteProject(input: {projectID: $projectID}) {
|
|
|
|
ok
|
|
|
|
project {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteProjectMutationFn = ApolloReactCommon.MutationFunction<DeleteProjectMutation, DeleteProjectMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteProjectMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteProjectMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteProjectMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteProjectMutation, { data, loading, error }] = useDeleteProjectMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteProjectMutation, DeleteProjectMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteProjectMutation, DeleteProjectMutationVariables>(DeleteProjectDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteProjectMutationHookResult = ReturnType<typeof useDeleteProjectMutation>;
|
|
|
|
export type DeleteProjectMutationResult = ApolloReactCommon.MutationResult<DeleteProjectMutation>;
|
|
|
|
export type DeleteProjectMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteProjectMutation, DeleteProjectMutationVariables>;
|
2020-07-05 01:02:57 +02:00
|
|
|
export const DeleteProjectMemberDocument = gql`
|
|
|
|
mutation deleteProjectMember($projectID: UUID!, $userID: UUID!) {
|
|
|
|
deleteProjectMember(input: {projectID: $projectID, userID: $userID}) {
|
|
|
|
ok
|
|
|
|
member {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
projectID
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteProjectMemberMutationFn = ApolloReactCommon.MutationFunction<DeleteProjectMemberMutation, DeleteProjectMemberMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteProjectMemberMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteProjectMemberMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteProjectMemberMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteProjectMemberMutation, { data, loading, error }] = useDeleteProjectMemberMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteProjectMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteProjectMemberMutation, DeleteProjectMemberMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteProjectMemberMutation, DeleteProjectMemberMutationVariables>(DeleteProjectMemberDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteProjectMemberMutationHookResult = ReturnType<typeof useDeleteProjectMemberMutation>;
|
|
|
|
export type DeleteProjectMemberMutationResult = ApolloReactCommon.MutationResult<DeleteProjectMemberMutation>;
|
|
|
|
export type DeleteProjectMemberMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteProjectMemberMutation, DeleteProjectMemberMutationVariables>;
|
|
|
|
export const SetProjectOwnerDocument = gql`
|
|
|
|
mutation setProjectOwner($projectID: UUID!, $ownerID: UUID!) {
|
|
|
|
setProjectOwner(input: {projectID: $projectID, ownerID: $ownerID}) {
|
|
|
|
ok
|
|
|
|
newOwner {
|
|
|
|
id
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prevOwner {
|
|
|
|
id
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type SetProjectOwnerMutationFn = ApolloReactCommon.MutationFunction<SetProjectOwnerMutation, SetProjectOwnerMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useSetProjectOwnerMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useSetProjectOwnerMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useSetProjectOwnerMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [setProjectOwnerMutation, { data, loading, error }] = useSetProjectOwnerMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* ownerID: // value for 'ownerID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useSetProjectOwnerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<SetProjectOwnerMutation, SetProjectOwnerMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<SetProjectOwnerMutation, SetProjectOwnerMutationVariables>(SetProjectOwnerDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type SetProjectOwnerMutationHookResult = ReturnType<typeof useSetProjectOwnerMutation>;
|
|
|
|
export type SetProjectOwnerMutationResult = ApolloReactCommon.MutationResult<SetProjectOwnerMutation>;
|
|
|
|
export type SetProjectOwnerMutationOptions = ApolloReactCommon.BaseMutationOptions<SetProjectOwnerMutation, SetProjectOwnerMutationVariables>;
|
|
|
|
export const UpdateProjectMemberRoleDocument = gql`
|
|
|
|
mutation updateProjectMemberRole($projectID: UUID!, $userID: UUID!, $roleCode: RoleCode!) {
|
|
|
|
updateProjectMemberRole(input: {projectID: $projectID, userID: $userID, roleCode: $roleCode}) {
|
|
|
|
ok
|
|
|
|
member {
|
|
|
|
id
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateProjectMemberRoleMutationFn = ApolloReactCommon.MutationFunction<UpdateProjectMemberRoleMutation, UpdateProjectMemberRoleMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateProjectMemberRoleMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateProjectMemberRoleMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateProjectMemberRoleMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateProjectMemberRoleMutation, { data, loading, error }] = useUpdateProjectMemberRoleMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* roleCode: // value for 'roleCode'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateProjectMemberRoleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateProjectMemberRoleMutation, UpdateProjectMemberRoleMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateProjectMemberRoleMutation, UpdateProjectMemberRoleMutationVariables>(UpdateProjectMemberRoleDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateProjectMemberRoleMutationHookResult = ReturnType<typeof useUpdateProjectMemberRoleMutation>;
|
|
|
|
export type UpdateProjectMemberRoleMutationResult = ApolloReactCommon.MutationResult<UpdateProjectMemberRoleMutation>;
|
|
|
|
export type UpdateProjectMemberRoleMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateProjectMemberRoleMutation, UpdateProjectMemberRoleMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const CreateTaskDocument = gql`
|
|
|
|
mutation createTask($taskGroupID: String!, $name: String!, $position: Float!) {
|
|
|
|
createTask(input: {taskGroupID: $taskGroupID, name: $name, position: $position}) {
|
|
|
|
...TaskFields
|
|
|
|
}
|
|
|
|
}
|
|
|
|
${TaskFieldsFragmentDoc}`;
|
|
|
|
export type CreateTaskMutationFn = ApolloReactCommon.MutationFunction<CreateTaskMutation, CreateTaskMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTaskMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTaskMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTaskMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTaskMutation, { data, loading, error }] = useCreateTaskMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskGroupID: // value for 'taskGroupID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTaskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTaskMutation, CreateTaskMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTaskMutation, CreateTaskMutationVariables>(CreateTaskDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTaskMutationHookResult = ReturnType<typeof useCreateTaskMutation>;
|
|
|
|
export type CreateTaskMutationResult = ApolloReactCommon.MutationResult<CreateTaskMutation>;
|
|
|
|
export type CreateTaskMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTaskMutation, CreateTaskMutationVariables>;
|
|
|
|
export const CreateTaskChecklistDocument = gql`
|
|
|
|
mutation createTaskChecklist($taskID: UUID!, $name: String!, $position: Float!) {
|
|
|
|
createTaskChecklist(input: {taskID: $taskID, name: $name, position: $position}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
position
|
|
|
|
items {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
taskChecklistID
|
|
|
|
complete
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateTaskChecklistMutationFn = ApolloReactCommon.MutationFunction<CreateTaskChecklistMutation, CreateTaskChecklistMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTaskChecklistMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTaskChecklistMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTaskChecklistMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTaskChecklistMutation, { data, loading, error }] = useCreateTaskChecklistMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTaskChecklistMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTaskChecklistMutation, CreateTaskChecklistMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTaskChecklistMutation, CreateTaskChecklistMutationVariables>(CreateTaskChecklistDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTaskChecklistMutationHookResult = ReturnType<typeof useCreateTaskChecklistMutation>;
|
|
|
|
export type CreateTaskChecklistMutationResult = ApolloReactCommon.MutationResult<CreateTaskChecklistMutation>;
|
|
|
|
export type CreateTaskChecklistMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTaskChecklistMutation, CreateTaskChecklistMutationVariables>;
|
2020-06-19 01:12:15 +02:00
|
|
|
export const CreateTaskChecklistItemDocument = gql`
|
|
|
|
mutation createTaskChecklistItem($taskChecklistID: UUID!, $name: String!, $position: Float!) {
|
|
|
|
createTaskChecklistItem(input: {taskChecklistID: $taskChecklistID, name: $name, position: $position}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
taskChecklistID
|
|
|
|
position
|
|
|
|
complete
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateTaskChecklistItemMutationFn = ApolloReactCommon.MutationFunction<CreateTaskChecklistItemMutation, CreateTaskChecklistItemMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTaskChecklistItemMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTaskChecklistItemMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTaskChecklistItemMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTaskChecklistItemMutation, { data, loading, error }] = useCreateTaskChecklistItemMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistID: // value for 'taskChecklistID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTaskChecklistItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTaskChecklistItemMutation, CreateTaskChecklistItemMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTaskChecklistItemMutation, CreateTaskChecklistItemMutationVariables>(CreateTaskChecklistItemDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTaskChecklistItemMutationHookResult = ReturnType<typeof useCreateTaskChecklistItemMutation>;
|
|
|
|
export type CreateTaskChecklistItemMutationResult = ApolloReactCommon.MutationResult<CreateTaskChecklistItemMutation>;
|
|
|
|
export type CreateTaskChecklistItemMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTaskChecklistItemMutation, CreateTaskChecklistItemMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const DeleteTaskChecklistDocument = gql`
|
|
|
|
mutation deleteTaskChecklist($taskChecklistID: UUID!) {
|
|
|
|
deleteTaskChecklist(input: {taskChecklistID: $taskChecklistID}) {
|
|
|
|
ok
|
|
|
|
taskChecklist {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteTaskChecklistMutationFn = ApolloReactCommon.MutationFunction<DeleteTaskChecklistMutation, DeleteTaskChecklistMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTaskChecklistMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTaskChecklistMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTaskChecklistMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTaskChecklistMutation, { data, loading, error }] = useDeleteTaskChecklistMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistID: // value for 'taskChecklistID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteTaskChecklistMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTaskChecklistMutation, DeleteTaskChecklistMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTaskChecklistMutation, DeleteTaskChecklistMutationVariables>(DeleteTaskChecklistDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteTaskChecklistMutationHookResult = ReturnType<typeof useDeleteTaskChecklistMutation>;
|
|
|
|
export type DeleteTaskChecklistMutationResult = ApolloReactCommon.MutationResult<DeleteTaskChecklistMutation>;
|
|
|
|
export type DeleteTaskChecklistMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTaskChecklistMutation, DeleteTaskChecklistMutationVariables>;
|
2020-06-19 01:12:15 +02:00
|
|
|
export const DeleteTaskChecklistItemDocument = gql`
|
|
|
|
mutation deleteTaskChecklistItem($taskChecklistItemID: UUID!) {
|
|
|
|
deleteTaskChecklistItem(input: {taskChecklistItemID: $taskChecklistItemID}) {
|
|
|
|
ok
|
|
|
|
taskChecklistItem {
|
|
|
|
id
|
|
|
|
taskChecklistID
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteTaskChecklistItemMutationFn = ApolloReactCommon.MutationFunction<DeleteTaskChecklistItemMutation, DeleteTaskChecklistItemMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTaskChecklistItemMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTaskChecklistItemMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTaskChecklistItemMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTaskChecklistItemMutation, { data, loading, error }] = useDeleteTaskChecklistItemMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistItemID: // value for 'taskChecklistItemID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteTaskChecklistItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTaskChecklistItemMutation, DeleteTaskChecklistItemMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTaskChecklistItemMutation, DeleteTaskChecklistItemMutationVariables>(DeleteTaskChecklistItemDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteTaskChecklistItemMutationHookResult = ReturnType<typeof useDeleteTaskChecklistItemMutation>;
|
|
|
|
export type DeleteTaskChecklistItemMutationResult = ApolloReactCommon.MutationResult<DeleteTaskChecklistItemMutation>;
|
|
|
|
export type DeleteTaskChecklistItemMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTaskChecklistItemMutation, DeleteTaskChecklistItemMutationVariables>;
|
|
|
|
export const SetTaskChecklistItemCompleteDocument = gql`
|
|
|
|
mutation setTaskChecklistItemComplete($taskChecklistItemID: UUID!, $complete: Boolean!) {
|
|
|
|
setTaskChecklistItemComplete(input: {taskChecklistItemID: $taskChecklistItemID, complete: $complete}) {
|
|
|
|
id
|
|
|
|
complete
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type SetTaskChecklistItemCompleteMutationFn = ApolloReactCommon.MutationFunction<SetTaskChecklistItemCompleteMutation, SetTaskChecklistItemCompleteMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useSetTaskChecklistItemCompleteMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useSetTaskChecklistItemCompleteMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useSetTaskChecklistItemCompleteMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [setTaskChecklistItemCompleteMutation, { data, loading, error }] = useSetTaskChecklistItemCompleteMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistItemID: // value for 'taskChecklistItemID'
|
|
|
|
* complete: // value for 'complete'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useSetTaskChecklistItemCompleteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<SetTaskChecklistItemCompleteMutation, SetTaskChecklistItemCompleteMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<SetTaskChecklistItemCompleteMutation, SetTaskChecklistItemCompleteMutationVariables>(SetTaskChecklistItemCompleteDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type SetTaskChecklistItemCompleteMutationHookResult = ReturnType<typeof useSetTaskChecklistItemCompleteMutation>;
|
|
|
|
export type SetTaskChecklistItemCompleteMutationResult = ApolloReactCommon.MutationResult<SetTaskChecklistItemCompleteMutation>;
|
|
|
|
export type SetTaskChecklistItemCompleteMutationOptions = ApolloReactCommon.BaseMutationOptions<SetTaskChecklistItemCompleteMutation, SetTaskChecklistItemCompleteMutationVariables>;
|
|
|
|
export const SetTaskCompleteDocument = gql`
|
|
|
|
mutation setTaskComplete($taskID: UUID!, $complete: Boolean!) {
|
|
|
|
setTaskComplete(input: {taskID: $taskID, complete: $complete}) {
|
|
|
|
...TaskFields
|
|
|
|
}
|
|
|
|
}
|
|
|
|
${TaskFieldsFragmentDoc}`;
|
|
|
|
export type SetTaskCompleteMutationFn = ApolloReactCommon.MutationFunction<SetTaskCompleteMutation, SetTaskCompleteMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useSetTaskCompleteMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useSetTaskCompleteMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useSetTaskCompleteMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [setTaskCompleteMutation, { data, loading, error }] = useSetTaskCompleteMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* complete: // value for 'complete'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useSetTaskCompleteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<SetTaskCompleteMutation, SetTaskCompleteMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<SetTaskCompleteMutation, SetTaskCompleteMutationVariables>(SetTaskCompleteDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type SetTaskCompleteMutationHookResult = ReturnType<typeof useSetTaskCompleteMutation>;
|
|
|
|
export type SetTaskCompleteMutationResult = ApolloReactCommon.MutationResult<SetTaskCompleteMutation>;
|
|
|
|
export type SetTaskCompleteMutationOptions = ApolloReactCommon.BaseMutationOptions<SetTaskCompleteMutation, SetTaskCompleteMutationVariables>;
|
2020-07-12 09:06:11 +02:00
|
|
|
export const UpdateTaskChecklistItemLocationDocument = gql`
|
|
|
|
mutation updateTaskChecklistItemLocation($checklistID: UUID!, $checklistItemID: UUID!, $position: Float!) {
|
|
|
|
updateTaskChecklistItemLocation(input: {checklistID: $checklistID, checklistItemID: $checklistItemID, position: $position}) {
|
|
|
|
checklistID
|
|
|
|
prevChecklistID
|
|
|
|
checklistItem {
|
|
|
|
id
|
|
|
|
taskChecklistID
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskChecklistItemLocationMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskChecklistItemLocationMutation, UpdateTaskChecklistItemLocationMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskChecklistItemLocationMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskChecklistItemLocationMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskChecklistItemLocationMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskChecklistItemLocationMutation, { data, loading, error }] = useUpdateTaskChecklistItemLocationMutation({
|
|
|
|
* variables: {
|
|
|
|
* checklistID: // value for 'checklistID'
|
|
|
|
* checklistItemID: // value for 'checklistItemID'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskChecklistItemLocationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskChecklistItemLocationMutation, UpdateTaskChecklistItemLocationMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskChecklistItemLocationMutation, UpdateTaskChecklistItemLocationMutationVariables>(UpdateTaskChecklistItemLocationDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskChecklistItemLocationMutationHookResult = ReturnType<typeof useUpdateTaskChecklistItemLocationMutation>;
|
|
|
|
export type UpdateTaskChecklistItemLocationMutationResult = ApolloReactCommon.MutationResult<UpdateTaskChecklistItemLocationMutation>;
|
|
|
|
export type UpdateTaskChecklistItemLocationMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskChecklistItemLocationMutation, UpdateTaskChecklistItemLocationMutationVariables>;
|
2020-06-19 01:12:15 +02:00
|
|
|
export const UpdateTaskChecklistItemNameDocument = gql`
|
|
|
|
mutation updateTaskChecklistItemName($taskChecklistItemID: UUID!, $name: String!) {
|
|
|
|
updateTaskChecklistItemName(input: {taskChecklistItemID: $taskChecklistItemID, name: $name}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskChecklistItemNameMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskChecklistItemNameMutation, UpdateTaskChecklistItemNameMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskChecklistItemNameMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskChecklistItemNameMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskChecklistItemNameMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskChecklistItemNameMutation, { data, loading, error }] = useUpdateTaskChecklistItemNameMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistItemID: // value for 'taskChecklistItemID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskChecklistItemNameMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskChecklistItemNameMutation, UpdateTaskChecklistItemNameMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskChecklistItemNameMutation, UpdateTaskChecklistItemNameMutationVariables>(UpdateTaskChecklistItemNameDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskChecklistItemNameMutationHookResult = ReturnType<typeof useUpdateTaskChecklistItemNameMutation>;
|
|
|
|
export type UpdateTaskChecklistItemNameMutationResult = ApolloReactCommon.MutationResult<UpdateTaskChecklistItemNameMutation>;
|
|
|
|
export type UpdateTaskChecklistItemNameMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskChecklistItemNameMutation, UpdateTaskChecklistItemNameMutationVariables>;
|
2020-07-12 09:06:11 +02:00
|
|
|
export const UpdateTaskChecklistLocationDocument = gql`
|
|
|
|
mutation updateTaskChecklistLocation($checklistID: UUID!, $position: Float!) {
|
|
|
|
updateTaskChecklistLocation(input: {checklistID: $checklistID, position: $position}) {
|
|
|
|
checklist {
|
|
|
|
id
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskChecklistLocationMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskChecklistLocationMutation, UpdateTaskChecklistLocationMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskChecklistLocationMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskChecklistLocationMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskChecklistLocationMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskChecklistLocationMutation, { data, loading, error }] = useUpdateTaskChecklistLocationMutation({
|
|
|
|
* variables: {
|
|
|
|
* checklistID: // value for 'checklistID'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskChecklistLocationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskChecklistLocationMutation, UpdateTaskChecklistLocationMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskChecklistLocationMutation, UpdateTaskChecklistLocationMutationVariables>(UpdateTaskChecklistLocationDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskChecklistLocationMutationHookResult = ReturnType<typeof useUpdateTaskChecklistLocationMutation>;
|
|
|
|
export type UpdateTaskChecklistLocationMutationResult = ApolloReactCommon.MutationResult<UpdateTaskChecklistLocationMutation>;
|
|
|
|
export type UpdateTaskChecklistLocationMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskChecklistLocationMutation, UpdateTaskChecklistLocationMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const UpdateTaskChecklistNameDocument = gql`
|
|
|
|
mutation updateTaskChecklistName($taskChecklistID: UUID!, $name: String!) {
|
|
|
|
updateTaskChecklistName(input: {taskChecklistID: $taskChecklistID, name: $name}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
position
|
|
|
|
items {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
taskChecklistID
|
|
|
|
complete
|
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskChecklistNameMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskChecklistNameMutation, UpdateTaskChecklistNameMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskChecklistNameMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskChecklistNameMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskChecklistNameMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskChecklistNameMutation, { data, loading, error }] = useUpdateTaskChecklistNameMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskChecklistID: // value for 'taskChecklistID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskChecklistNameMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskChecklistNameMutation, UpdateTaskChecklistNameMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskChecklistNameMutation, UpdateTaskChecklistNameMutationVariables>(UpdateTaskChecklistNameDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskChecklistNameMutationHookResult = ReturnType<typeof useUpdateTaskChecklistNameMutation>;
|
|
|
|
export type UpdateTaskChecklistNameMutationResult = ApolloReactCommon.MutationResult<UpdateTaskChecklistNameMutation>;
|
|
|
|
export type UpdateTaskChecklistNameMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskChecklistNameMutation, UpdateTaskChecklistNameMutationVariables>;
|
2020-06-19 01:12:15 +02:00
|
|
|
export const UpdateTaskGroupNameDocument = gql`
|
|
|
|
mutation updateTaskGroupName($taskGroupID: UUID!, $name: String!) {
|
|
|
|
updateTaskGroupName(input: {taskGroupID: $taskGroupID, name: $name}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskGroupNameMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskGroupNameMutation, UpdateTaskGroupNameMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskGroupNameMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskGroupNameMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskGroupNameMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskGroupNameMutation, { data, loading, error }] = useUpdateTaskGroupNameMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskGroupID: // value for 'taskGroupID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskGroupNameMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskGroupNameMutation, UpdateTaskGroupNameMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskGroupNameMutation, UpdateTaskGroupNameMutationVariables>(UpdateTaskGroupNameDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskGroupNameMutationHookResult = ReturnType<typeof useUpdateTaskGroupNameMutation>;
|
|
|
|
export type UpdateTaskGroupNameMutationResult = ApolloReactCommon.MutationResult<UpdateTaskGroupNameMutation>;
|
|
|
|
export type UpdateTaskGroupNameMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskGroupNameMutation, UpdateTaskGroupNameMutationVariables>;
|
2020-06-21 00:49:11 +02:00
|
|
|
export const CreateTeamDocument = gql`
|
|
|
|
mutation createTeam($name: String!, $organizationID: UUID!) {
|
|
|
|
createTeam(input: {name: $name, organizationID: $organizationID}) {
|
|
|
|
id
|
|
|
|
createdAt
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateTeamMutationFn = ApolloReactCommon.MutationFunction<CreateTeamMutation, CreateTeamMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTeamMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTeamMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTeamMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTeamMutation, { data, loading, error }] = useCreateTeamMutation({
|
|
|
|
* variables: {
|
|
|
|
* name: // value for 'name'
|
|
|
|
* organizationID: // value for 'organizationID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTeamMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTeamMutation, CreateTeamMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTeamMutation, CreateTeamMutationVariables>(CreateTeamDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTeamMutationHookResult = ReturnType<typeof useCreateTeamMutation>;
|
|
|
|
export type CreateTeamMutationResult = ApolloReactCommon.MutationResult<CreateTeamMutation>;
|
|
|
|
export type CreateTeamMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTeamMutation, CreateTeamMutationVariables>;
|
2020-07-05 01:02:57 +02:00
|
|
|
export const CreateTeamMemberDocument = gql`
|
|
|
|
mutation createTeamMember($userID: UUID!, $teamID: UUID!) {
|
|
|
|
createTeamMember(input: {userID: $userID, teamID: $teamID}) {
|
|
|
|
team {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
teamMember {
|
|
|
|
id
|
|
|
|
username
|
|
|
|
fullName
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateTeamMemberMutationFn = ApolloReactCommon.MutationFunction<CreateTeamMemberMutation, CreateTeamMemberMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateTeamMemberMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateTeamMemberMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateTeamMemberMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createTeamMemberMutation, { data, loading, error }] = useCreateTeamMemberMutation({
|
|
|
|
* variables: {
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* teamID: // value for 'teamID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateTeamMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateTeamMemberMutation, CreateTeamMemberMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateTeamMemberMutation, CreateTeamMemberMutationVariables>(CreateTeamMemberDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateTeamMemberMutationHookResult = ReturnType<typeof useCreateTeamMemberMutation>;
|
|
|
|
export type CreateTeamMemberMutationResult = ApolloReactCommon.MutationResult<CreateTeamMemberMutation>;
|
|
|
|
export type CreateTeamMemberMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateTeamMemberMutation, CreateTeamMemberMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const DeleteTeamDocument = gql`
|
|
|
|
mutation deleteTeam($teamID: UUID!) {
|
|
|
|
deleteTeam(input: {teamID: $teamID}) {
|
|
|
|
ok
|
|
|
|
team {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteTeamMutationFn = ApolloReactCommon.MutationFunction<DeleteTeamMutation, DeleteTeamMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTeamMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTeamMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTeamMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTeamMutation, { data, loading, error }] = useDeleteTeamMutation({
|
|
|
|
* variables: {
|
|
|
|
* teamID: // value for 'teamID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteTeamMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTeamMutation, DeleteTeamMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTeamMutation, DeleteTeamMutationVariables>(DeleteTeamDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteTeamMutationHookResult = ReturnType<typeof useDeleteTeamMutation>;
|
|
|
|
export type DeleteTeamMutationResult = ApolloReactCommon.MutationResult<DeleteTeamMutation>;
|
|
|
|
export type DeleteTeamMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTeamMutation, DeleteTeamMutationVariables>;
|
2020-07-05 01:02:57 +02:00
|
|
|
export const DeleteTeamMemberDocument = gql`
|
2020-07-12 09:06:11 +02:00
|
|
|
mutation deleteTeamMember($teamID: UUID!, $userID: UUID!, $newOwnerID: UUID) {
|
|
|
|
deleteTeamMember(input: {teamID: $teamID, userID: $userID, newOwnerID: $newOwnerID}) {
|
2020-07-05 01:02:57 +02:00
|
|
|
teamID
|
|
|
|
userID
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteTeamMemberMutationFn = ApolloReactCommon.MutationFunction<DeleteTeamMemberMutation, DeleteTeamMemberMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteTeamMemberMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteTeamMemberMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteTeamMemberMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteTeamMemberMutation, { data, loading, error }] = useDeleteTeamMemberMutation({
|
|
|
|
* variables: {
|
|
|
|
* teamID: // value for 'teamID'
|
|
|
|
* userID: // value for 'userID'
|
2020-07-12 09:06:11 +02:00
|
|
|
* newOwnerID: // value for 'newOwnerID'
|
2020-07-05 01:02:57 +02:00
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteTeamMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteTeamMemberMutation, DeleteTeamMemberMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteTeamMemberMutation, DeleteTeamMemberMutationVariables>(DeleteTeamMemberDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteTeamMemberMutationHookResult = ReturnType<typeof useDeleteTeamMemberMutation>;
|
|
|
|
export type DeleteTeamMemberMutationResult = ApolloReactCommon.MutationResult<DeleteTeamMemberMutation>;
|
|
|
|
export type DeleteTeamMemberMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteTeamMemberMutation, DeleteTeamMemberMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const GetTeamDocument = gql`
|
|
|
|
query getTeam($teamID: UUID!) {
|
|
|
|
findTeam(input: {teamID: $teamID}) {
|
|
|
|
id
|
|
|
|
createdAt
|
|
|
|
name
|
2020-07-05 01:02:57 +02:00
|
|
|
members {
|
|
|
|
id
|
|
|
|
fullName
|
|
|
|
username
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
2020-07-18 02:40:05 +02:00
|
|
|
owned {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
member {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
}
|
|
|
|
projects(input: {teamID: $teamID}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
team {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
users {
|
|
|
|
id
|
|
|
|
email
|
|
|
|
fullName
|
|
|
|
username
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
2020-07-18 02:40:05 +02:00
|
|
|
owned {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
member {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
}
|
|
|
|
`;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useGetTeamQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useGetTeamQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useGetTeamQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useGetTeamQuery({
|
|
|
|
* variables: {
|
|
|
|
* teamID: // value for 'teamID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useGetTeamQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<GetTeamQuery, GetTeamQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<GetTeamQuery, GetTeamQueryVariables>(GetTeamDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useGetTeamLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetTeamQuery, GetTeamQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<GetTeamQuery, GetTeamQueryVariables>(GetTeamDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type GetTeamQueryHookResult = ReturnType<typeof useGetTeamQuery>;
|
|
|
|
export type GetTeamLazyQueryHookResult = ReturnType<typeof useGetTeamLazyQuery>;
|
|
|
|
export type GetTeamQueryResult = ApolloReactCommon.QueryResult<GetTeamQuery, GetTeamQueryVariables>;
|
2020-05-31 06:11:19 +02:00
|
|
|
export const ToggleTaskLabelDocument = gql`
|
|
|
|
mutation toggleTaskLabel($taskID: UUID!, $projectLabelID: UUID!) {
|
|
|
|
toggleTaskLabel(input: {taskID: $taskID, projectLabelID: $projectLabelID}) {
|
|
|
|
active
|
|
|
|
task {
|
|
|
|
id
|
|
|
|
labels {
|
|
|
|
id
|
|
|
|
assignedDate
|
|
|
|
projectLabel {
|
|
|
|
id
|
|
|
|
createdDate
|
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
colorHex
|
|
|
|
name
|
|
|
|
position
|
|
|
|
}
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type ToggleTaskLabelMutationFn = ApolloReactCommon.MutationFunction<ToggleTaskLabelMutation, ToggleTaskLabelMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useToggleTaskLabelMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useToggleTaskLabelMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useToggleTaskLabelMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [toggleTaskLabelMutation, { data, loading, error }] = useToggleTaskLabelMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* projectLabelID: // value for 'projectLabelID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useToggleTaskLabelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<ToggleTaskLabelMutation, ToggleTaskLabelMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<ToggleTaskLabelMutation, ToggleTaskLabelMutationVariables>(ToggleTaskLabelDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type ToggleTaskLabelMutationHookResult = ReturnType<typeof useToggleTaskLabelMutation>;
|
|
|
|
export type ToggleTaskLabelMutationResult = ApolloReactCommon.MutationResult<ToggleTaskLabelMutation>;
|
|
|
|
export type ToggleTaskLabelMutationOptions = ApolloReactCommon.BaseMutationOptions<ToggleTaskLabelMutation, ToggleTaskLabelMutationVariables>;
|
2020-04-21 01:04:27 +02:00
|
|
|
export const UnassignTaskDocument = gql`
|
|
|
|
mutation unassignTask($taskID: UUID!, $userID: UUID!) {
|
|
|
|
unassignTask(input: {taskID: $taskID, userID: $userID}) {
|
|
|
|
assigned {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-06-13 00:21:58 +02:00
|
|
|
fullName
|
2020-04-21 01:04:27 +02:00
|
|
|
}
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-21 01:04:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UnassignTaskMutationFn = ApolloReactCommon.MutationFunction<UnassignTaskMutation, UnassignTaskMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUnassignTaskMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUnassignTaskMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUnassignTaskMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [unassignTaskMutation, { data, loading, error }] = useUnassignTaskMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUnassignTaskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UnassignTaskMutation, UnassignTaskMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UnassignTaskMutation, UnassignTaskMutationVariables>(UnassignTaskDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UnassignTaskMutationHookResult = ReturnType<typeof useUnassignTaskMutation>;
|
|
|
|
export type UnassignTaskMutationResult = ApolloReactCommon.MutationResult<UnassignTaskMutation>;
|
|
|
|
export type UnassignTaskMutationOptions = ApolloReactCommon.BaseMutationOptions<UnassignTaskMutation, UnassignTaskMutationVariables>;
|
2020-05-28 03:12:50 +02:00
|
|
|
export const UpdateProjectLabelDocument = gql`
|
|
|
|
mutation updateProjectLabel($projectLabelID: UUID!, $labelColorID: UUID!, $name: String!) {
|
|
|
|
updateProjectLabel(input: {projectLabelID: $projectLabelID, labelColorID: $labelColorID, name: $name}) {
|
|
|
|
id
|
|
|
|
createdDate
|
|
|
|
labelColor {
|
|
|
|
id
|
|
|
|
colorHex
|
|
|
|
name
|
|
|
|
position
|
|
|
|
}
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateProjectLabelMutationFn = ApolloReactCommon.MutationFunction<UpdateProjectLabelMutation, UpdateProjectLabelMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateProjectLabelMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateProjectLabelMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateProjectLabelMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateProjectLabelMutation, { data, loading, error }] = useUpdateProjectLabelMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectLabelID: // value for 'projectLabelID'
|
|
|
|
* labelColorID: // value for 'labelColorID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateProjectLabelMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateProjectLabelMutation, UpdateProjectLabelMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateProjectLabelMutation, UpdateProjectLabelMutationVariables>(UpdateProjectLabelDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateProjectLabelMutationHookResult = ReturnType<typeof useUpdateProjectLabelMutation>;
|
|
|
|
export type UpdateProjectLabelMutationResult = ApolloReactCommon.MutationResult<UpdateProjectLabelMutation>;
|
|
|
|
export type UpdateProjectLabelMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateProjectLabelMutation, UpdateProjectLabelMutationVariables>;
|
2020-05-31 06:11:19 +02:00
|
|
|
export const UpdateProjectNameDocument = gql`
|
|
|
|
mutation updateProjectName($projectID: UUID!, $name: String!) {
|
|
|
|
updateProjectName(input: {projectID: $projectID, name: $name}) {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateProjectNameMutationFn = ApolloReactCommon.MutationFunction<UpdateProjectNameMutation, UpdateProjectNameMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateProjectNameMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateProjectNameMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateProjectNameMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateProjectNameMutation, { data, loading, error }] = useUpdateProjectNameMutation({
|
|
|
|
* variables: {
|
|
|
|
* projectID: // value for 'projectID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateProjectNameMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateProjectNameMutation, UpdateProjectNameMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateProjectNameMutation, UpdateProjectNameMutationVariables>(UpdateProjectNameDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateProjectNameMutationHookResult = ReturnType<typeof useUpdateProjectNameMutation>;
|
|
|
|
export type UpdateProjectNameMutationResult = ApolloReactCommon.MutationResult<UpdateProjectNameMutation>;
|
|
|
|
export type UpdateProjectNameMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateProjectNameMutation, UpdateProjectNameMutationVariables>;
|
2020-04-20 05:02:55 +02:00
|
|
|
export const UpdateTaskDescriptionDocument = gql`
|
|
|
|
mutation updateTaskDescription($taskID: UUID!, $description: String!) {
|
|
|
|
updateTaskDescription(input: {taskID: $taskID, description: $description}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-06-13 00:21:58 +02:00
|
|
|
description
|
2020-04-20 05:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskDescriptionMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskDescriptionMutation, UpdateTaskDescriptionMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskDescriptionMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskDescriptionMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskDescriptionMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskDescriptionMutation, { data, loading, error }] = useUpdateTaskDescriptionMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* description: // value for 'description'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskDescriptionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskDescriptionMutation, UpdateTaskDescriptionMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskDescriptionMutation, UpdateTaskDescriptionMutationVariables>(UpdateTaskDescriptionDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskDescriptionMutationHookResult = ReturnType<typeof useUpdateTaskDescriptionMutation>;
|
|
|
|
export type UpdateTaskDescriptionMutationResult = ApolloReactCommon.MutationResult<UpdateTaskDescriptionMutation>;
|
|
|
|
export type UpdateTaskDescriptionMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskDescriptionMutation, UpdateTaskDescriptionMutationVariables>;
|
2020-06-16 00:36:59 +02:00
|
|
|
export const UpdateTaskDueDateDocument = gql`
|
|
|
|
mutation updateTaskDueDate($taskID: UUID!, $dueDate: Time) {
|
|
|
|
updateTaskDueDate(input: {taskID: $taskID, dueDate: $dueDate}) {
|
|
|
|
id
|
|
|
|
dueDate
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskDueDateMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskDueDateMutation, UpdateTaskDueDateMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskDueDateMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskDueDateMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskDueDateMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskDueDateMutation, { data, loading, error }] = useUpdateTaskDueDateMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* dueDate: // value for 'dueDate'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskDueDateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskDueDateMutation, UpdateTaskDueDateMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskDueDateMutation, UpdateTaskDueDateMutationVariables>(UpdateTaskDueDateDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskDueDateMutationHookResult = ReturnType<typeof useUpdateTaskDueDateMutation>;
|
|
|
|
export type UpdateTaskDueDateMutationResult = ApolloReactCommon.MutationResult<UpdateTaskDueDateMutation>;
|
|
|
|
export type UpdateTaskDueDateMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskDueDateMutation, UpdateTaskDueDateMutationVariables>;
|
2020-04-11 04:53:03 +02:00
|
|
|
export const UpdateTaskGroupLocationDocument = gql`
|
|
|
|
mutation updateTaskGroupLocation($taskGroupID: UUID!, $position: Float!) {
|
|
|
|
updateTaskGroupLocation(input: {taskGroupID: $taskGroupID, position: $position}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 04:53:03 +02:00
|
|
|
position
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskGroupLocationMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskGroupLocationMutation, UpdateTaskGroupLocationMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskGroupLocationMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskGroupLocationMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskGroupLocationMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskGroupLocationMutation, { data, loading, error }] = useUpdateTaskGroupLocationMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskGroupID: // value for 'taskGroupID'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateTaskGroupLocationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskGroupLocationMutation, UpdateTaskGroupLocationMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskGroupLocationMutation, UpdateTaskGroupLocationMutationVariables>(UpdateTaskGroupLocationDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateTaskGroupLocationMutationHookResult = ReturnType<typeof useUpdateTaskGroupLocationMutation>;
|
|
|
|
export type UpdateTaskGroupLocationMutationResult = ApolloReactCommon.MutationResult<UpdateTaskGroupLocationMutation>;
|
|
|
|
export type UpdateTaskGroupLocationMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskGroupLocationMutation, UpdateTaskGroupLocationMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
export const UpdateTaskLocationDocument = gql`
|
2020-06-01 04:20:03 +02:00
|
|
|
mutation updateTaskLocation($taskID: UUID!, $taskGroupID: UUID!, $position: Float!) {
|
2020-04-11 04:22:58 +02:00
|
|
|
updateTaskLocation(input: {taskID: $taskID, taskGroupID: $taskGroupID, position: $position}) {
|
2020-06-01 04:20:03 +02:00
|
|
|
previousTaskGroupID
|
|
|
|
task {
|
|
|
|
id
|
|
|
|
createdAt
|
|
|
|
name
|
|
|
|
position
|
|
|
|
taskGroup {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskLocationMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskLocationMutation, UpdateTaskLocationMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskLocationMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskLocationMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskLocationMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskLocationMutation, { data, loading, error }] = useUpdateTaskLocationMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* taskGroupID: // value for 'taskGroupID'
|
|
|
|
* position: // value for 'position'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
2020-04-11 04:22:58 +02:00
|
|
|
export function useUpdateTaskLocationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskLocationMutation, UpdateTaskLocationMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskLocationMutation, UpdateTaskLocationMutationVariables>(UpdateTaskLocationDocument, baseOptions);
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
export type UpdateTaskLocationMutationHookResult = ReturnType<typeof useUpdateTaskLocationMutation>;
|
|
|
|
export type UpdateTaskLocationMutationResult = ApolloReactCommon.MutationResult<UpdateTaskLocationMutation>;
|
2020-04-11 04:22:58 +02:00
|
|
|
export type UpdateTaskLocationMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskLocationMutation, UpdateTaskLocationMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
export const UpdateTaskNameDocument = gql`
|
2020-04-11 04:22:58 +02:00
|
|
|
mutation updateTaskName($taskID: String!, $name: String!) {
|
|
|
|
updateTaskName(input: {taskID: $taskID, name: $name}) {
|
2020-05-27 02:53:31 +02:00
|
|
|
id
|
2020-04-11 04:22:58 +02:00
|
|
|
name
|
|
|
|
position
|
2020-04-10 05:27:57 +02:00
|
|
|
}
|
2020-04-11 04:22:58 +02:00
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateTaskNameMutationFn = ApolloReactCommon.MutationFunction<UpdateTaskNameMutation, UpdateTaskNameMutationVariables>;
|
2020-04-10 05:27:57 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateTaskNameMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateTaskNameMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateTaskNameMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateTaskNameMutation, { data, loading, error }] = useUpdateTaskNameMutation({
|
|
|
|
* variables: {
|
|
|
|
* taskID: // value for 'taskID'
|
|
|
|
* name: // value for 'name'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
2020-04-11 04:22:58 +02:00
|
|
|
export function useUpdateTaskNameMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateTaskNameMutation, UpdateTaskNameMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateTaskNameMutation, UpdateTaskNameMutationVariables>(UpdateTaskNameDocument, baseOptions);
|
|
|
|
}
|
2020-04-10 05:27:57 +02:00
|
|
|
export type UpdateTaskNameMutationHookResult = ReturnType<typeof useUpdateTaskNameMutation>;
|
|
|
|
export type UpdateTaskNameMutationResult = ApolloReactCommon.MutationResult<UpdateTaskNameMutation>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export type UpdateTaskNameMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateTaskNameMutation, UpdateTaskNameMutationVariables>;
|
|
|
|
export const CreateUserAccountDocument = gql`
|
2020-07-05 01:02:57 +02:00
|
|
|
mutation createUserAccount($username: String!, $roleCode: String!, $email: String!, $fullName: String!, $initials: String!, $password: String!) {
|
|
|
|
createUserAccount(input: {roleCode: $roleCode, username: $username, email: $email, fullName: $fullName, initials: $initials, password: $password}) {
|
2020-06-23 22:20:53 +02:00
|
|
|
id
|
|
|
|
email
|
|
|
|
fullName
|
|
|
|
initials
|
|
|
|
username
|
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
2020-07-05 01:02:57 +02:00
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type CreateUserAccountMutationFn = ApolloReactCommon.MutationFunction<CreateUserAccountMutation, CreateUserAccountMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useCreateUserAccountMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useCreateUserAccountMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useCreateUserAccountMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [createUserAccountMutation, { data, loading, error }] = useCreateUserAccountMutation({
|
|
|
|
* variables: {
|
|
|
|
* username: // value for 'username'
|
2020-07-05 01:02:57 +02:00
|
|
|
* roleCode: // value for 'roleCode'
|
2020-06-23 22:20:53 +02:00
|
|
|
* email: // value for 'email'
|
|
|
|
* fullName: // value for 'fullName'
|
|
|
|
* initials: // value for 'initials'
|
|
|
|
* password: // value for 'password'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useCreateUserAccountMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<CreateUserAccountMutation, CreateUserAccountMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<CreateUserAccountMutation, CreateUserAccountMutationVariables>(CreateUserAccountDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type CreateUserAccountMutationHookResult = ReturnType<typeof useCreateUserAccountMutation>;
|
|
|
|
export type CreateUserAccountMutationResult = ApolloReactCommon.MutationResult<CreateUserAccountMutation>;
|
|
|
|
export type CreateUserAccountMutationOptions = ApolloReactCommon.BaseMutationOptions<CreateUserAccountMutation, CreateUserAccountMutationVariables>;
|
2020-07-05 01:02:57 +02:00
|
|
|
export const DeleteUserAccountDocument = gql`
|
|
|
|
mutation deleteUserAccount($userID: UUID!) {
|
|
|
|
deleteUserAccount(input: {userID: $userID}) {
|
|
|
|
ok
|
|
|
|
userAccount {
|
|
|
|
id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type DeleteUserAccountMutationFn = ApolloReactCommon.MutationFunction<DeleteUserAccountMutation, DeleteUserAccountMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useDeleteUserAccountMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useDeleteUserAccountMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useDeleteUserAccountMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [deleteUserAccountMutation, { data, loading, error }] = useDeleteUserAccountMutation({
|
|
|
|
* variables: {
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useDeleteUserAccountMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<DeleteUserAccountMutation, DeleteUserAccountMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<DeleteUserAccountMutation, DeleteUserAccountMutationVariables>(DeleteUserAccountDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type DeleteUserAccountMutationHookResult = ReturnType<typeof useDeleteUserAccountMutation>;
|
|
|
|
export type DeleteUserAccountMutationResult = ApolloReactCommon.MutationResult<DeleteUserAccountMutation>;
|
|
|
|
export type DeleteUserAccountMutationOptions = ApolloReactCommon.BaseMutationOptions<DeleteUserAccountMutation, DeleteUserAccountMutationVariables>;
|
2020-07-12 09:06:11 +02:00
|
|
|
export const UpdateUserRoleDocument = gql`
|
|
|
|
mutation updateUserRole($userID: UUID!, $roleCode: RoleCode!) {
|
|
|
|
updateUserRole(input: {userID: $userID, roleCode: $roleCode}) {
|
|
|
|
user {
|
|
|
|
id
|
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
export type UpdateUserRoleMutationFn = ApolloReactCommon.MutationFunction<UpdateUserRoleMutation, UpdateUserRoleMutationVariables>;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUpdateUserRoleMutation__
|
|
|
|
*
|
|
|
|
* To run a mutation, you first call `useUpdateUserRoleMutation` within a React component and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUpdateUserRoleMutation` returns a tuple that includes:
|
|
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const [updateUserRoleMutation, { data, loading, error }] = useUpdateUserRoleMutation({
|
|
|
|
* variables: {
|
|
|
|
* userID: // value for 'userID'
|
|
|
|
* roleCode: // value for 'roleCode'
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUpdateUserRoleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<UpdateUserRoleMutation, UpdateUserRoleMutationVariables>) {
|
|
|
|
return ApolloReactHooks.useMutation<UpdateUserRoleMutation, UpdateUserRoleMutationVariables>(UpdateUserRoleDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UpdateUserRoleMutationHookResult = ReturnType<typeof useUpdateUserRoleMutation>;
|
|
|
|
export type UpdateUserRoleMutationResult = ApolloReactCommon.MutationResult<UpdateUserRoleMutation>;
|
|
|
|
export type UpdateUserRoleMutationOptions = ApolloReactCommon.BaseMutationOptions<UpdateUserRoleMutation, UpdateUserRoleMutationVariables>;
|
2020-06-23 22:20:53 +02:00
|
|
|
export const UsersDocument = gql`
|
|
|
|
query users {
|
|
|
|
users {
|
|
|
|
id
|
|
|
|
email
|
|
|
|
fullName
|
|
|
|
username
|
2020-07-05 01:02:57 +02:00
|
|
|
role {
|
|
|
|
code
|
|
|
|
name
|
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
profileIcon {
|
|
|
|
url
|
|
|
|
initials
|
|
|
|
bgColor
|
|
|
|
}
|
2020-07-18 02:40:05 +02:00
|
|
|
owned {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
member {
|
|
|
|
teams {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
projects {
|
|
|
|
id
|
|
|
|
name
|
|
|
|
}
|
|
|
|
}
|
2020-06-23 22:20:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
`;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __useUsersQuery__
|
|
|
|
*
|
|
|
|
* To run a query within a React component, call `useUsersQuery` and pass it any options that fit your needs.
|
|
|
|
* When your component renders, `useUsersQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
|
|
* you can use to render your UI.
|
|
|
|
*
|
|
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* const { data, loading, error } = useUsersQuery({
|
|
|
|
* variables: {
|
|
|
|
* },
|
|
|
|
* });
|
|
|
|
*/
|
|
|
|
export function useUsersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<UsersQuery, UsersQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useQuery<UsersQuery, UsersQueryVariables>(UsersDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export function useUsersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<UsersQuery, UsersQueryVariables>) {
|
|
|
|
return ApolloReactHooks.useLazyQuery<UsersQuery, UsersQueryVariables>(UsersDocument, baseOptions);
|
|
|
|
}
|
|
|
|
export type UsersQueryHookResult = ReturnType<typeof useUsersQuery>;
|
|
|
|
export type UsersLazyQueryHookResult = ReturnType<typeof useUsersLazyQuery>;
|
|
|
|
export type UsersQueryResult = ApolloReactCommon.QueryResult<UsersQuery, UsersQueryVariables>;
|