fe70f30a29
* Added prisma to suggested extension in container * Added comments and authors on drawer with proper resolving * Fix lint * Fix console log * Fixed generated front graphql from rebase
1941 lines
72 KiB
TypeScript
1941 lines
72 KiB
TypeScript
import { gql } from '@apollo/client';
|
|
import * as Apollo from '@apollo/client';
|
|
export type Maybe<T> = T | null;
|
|
export type InputMaybe<T> = Maybe<T>;
|
|
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
|
|
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
|
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
|
|
const defaultOptions = {} as const;
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: string;
|
|
String: string;
|
|
Boolean: boolean;
|
|
Int: number;
|
|
Float: number;
|
|
DateTime: any;
|
|
JSON: any;
|
|
};
|
|
|
|
export type AffectedRows = {
|
|
__typename?: 'AffectedRows';
|
|
count: Scalars['Int'];
|
|
};
|
|
|
|
export type BoolFilter = {
|
|
equals?: InputMaybe<Scalars['Boolean']>;
|
|
not?: InputMaybe<NestedBoolFilter>;
|
|
};
|
|
|
|
export type Comment = {
|
|
__typename?: 'Comment';
|
|
author: User;
|
|
authorId: Scalars['String'];
|
|
body: Scalars['String'];
|
|
commentThread: CommentThread;
|
|
commentThreadId: Scalars['String'];
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type CommentCreateInput = {
|
|
author: UserCreateNestedOneWithoutCommentsInput;
|
|
body: Scalars['String'];
|
|
commentThread: CommentThreadCreateNestedOneWithoutCommentsInput;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
id: Scalars['String'];
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type CommentCreateManyCommentThreadInput = {
|
|
authorId: Scalars['String'];
|
|
body: Scalars['String'];
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
id: Scalars['String'];
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type CommentCreateManyCommentThreadInputEnvelope = {
|
|
data: Array<CommentCreateManyCommentThreadInput>;
|
|
skipDuplicates?: InputMaybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
export type CommentCreateNestedManyWithoutCommentThreadInput = {
|
|
createMany?: InputMaybe<CommentCreateManyCommentThreadInputEnvelope>;
|
|
};
|
|
|
|
export type CommentListRelationFilter = {
|
|
every?: InputMaybe<CommentWhereInput>;
|
|
none?: InputMaybe<CommentWhereInput>;
|
|
some?: InputMaybe<CommentWhereInput>;
|
|
};
|
|
|
|
export type CommentOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type CommentThread = {
|
|
__typename?: 'CommentThread';
|
|
commentThreadTargets?: Maybe<Array<CommentThreadTarget>>;
|
|
comments?: Maybe<Array<Comment>>;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type CommentThreadCreateInput = {
|
|
commentThreadTargets?: InputMaybe<CommentThreadTargetCreateNestedManyWithoutCommentThreadInput>;
|
|
comments?: InputMaybe<CommentCreateNestedManyWithoutCommentThreadInput>;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
id: Scalars['String'];
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type CommentThreadCreateNestedOneWithoutCommentsInput = {
|
|
connect?: InputMaybe<CommentThreadWhereUniqueInput>;
|
|
};
|
|
|
|
export type CommentThreadOrderByWithRelationInput = {
|
|
commentThreadTargets?: InputMaybe<CommentThreadTargetOrderByRelationAggregateInput>;
|
|
comments?: InputMaybe<CommentOrderByRelationAggregateInput>;
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type CommentThreadRelationFilter = {
|
|
is?: InputMaybe<CommentThreadWhereInput>;
|
|
isNot?: InputMaybe<CommentThreadWhereInput>;
|
|
};
|
|
|
|
export enum CommentThreadScalarFieldEnum {
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
Id = 'id',
|
|
UpdatedAt = 'updatedAt',
|
|
WorkspaceId = 'workspaceId'
|
|
}
|
|
|
|
export type CommentThreadTarget = {
|
|
__typename?: 'CommentThreadTarget';
|
|
commentThread: CommentThread;
|
|
commentThreadId: Scalars['String'];
|
|
commentableId: Scalars['String'];
|
|
commentableType: CommentableType;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type CommentThreadTargetCreateManyCommentThreadInput = {
|
|
commentableId: Scalars['String'];
|
|
commentableType: CommentableType;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
id: Scalars['String'];
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type CommentThreadTargetCreateManyCommentThreadInputEnvelope = {
|
|
data: Array<CommentThreadTargetCreateManyCommentThreadInput>;
|
|
skipDuplicates?: InputMaybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
export type CommentThreadTargetCreateNestedManyWithoutCommentThreadInput = {
|
|
createMany?: InputMaybe<CommentThreadTargetCreateManyCommentThreadInputEnvelope>;
|
|
};
|
|
|
|
export type CommentThreadTargetListRelationFilter = {
|
|
every?: InputMaybe<CommentThreadTargetWhereInput>;
|
|
none?: InputMaybe<CommentThreadTargetWhereInput>;
|
|
some?: InputMaybe<CommentThreadTargetWhereInput>;
|
|
};
|
|
|
|
export type CommentThreadTargetOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type CommentThreadTargetWhereInput = {
|
|
AND?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
|
|
NOT?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
|
|
OR?: InputMaybe<Array<CommentThreadTargetWhereInput>>;
|
|
commentThread?: InputMaybe<CommentThreadRelationFilter>;
|
|
commentThreadId?: InputMaybe<StringFilter>;
|
|
commentableId?: InputMaybe<StringFilter>;
|
|
commentableType?: InputMaybe<EnumCommentableTypeFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type CommentThreadWhereInput = {
|
|
AND?: InputMaybe<Array<CommentThreadWhereInput>>;
|
|
NOT?: InputMaybe<Array<CommentThreadWhereInput>>;
|
|
OR?: InputMaybe<Array<CommentThreadWhereInput>>;
|
|
commentThreadTargets?: InputMaybe<CommentThreadTargetListRelationFilter>;
|
|
comments?: InputMaybe<CommentListRelationFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type CommentThreadWhereUniqueInput = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type CommentWhereInput = {
|
|
AND?: InputMaybe<Array<CommentWhereInput>>;
|
|
NOT?: InputMaybe<Array<CommentWhereInput>>;
|
|
OR?: InputMaybe<Array<CommentWhereInput>>;
|
|
author?: InputMaybe<UserRelationFilter>;
|
|
authorId?: InputMaybe<StringFilter>;
|
|
body?: InputMaybe<StringFilter>;
|
|
commentThread?: InputMaybe<CommentThreadRelationFilter>;
|
|
commentThreadId?: InputMaybe<StringFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export enum CommentableType {
|
|
Company = 'Company',
|
|
Person = 'Person'
|
|
}
|
|
|
|
export type Company = {
|
|
__typename?: 'Company';
|
|
_commentCount: Scalars['Int'];
|
|
accountOwner?: Maybe<User>;
|
|
accountOwnerId?: Maybe<Scalars['String']>;
|
|
address: Scalars['String'];
|
|
commentThreads: Array<CommentThread>;
|
|
comments: Array<Comment>;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
domainName: Scalars['String'];
|
|
employees?: Maybe<Scalars['Int']>;
|
|
id: Scalars['ID'];
|
|
name: Scalars['String'];
|
|
people?: Maybe<Array<Person>>;
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type CompanyCreateInput = {
|
|
accountOwner?: InputMaybe<UserCreateNestedOneWithoutCompaniesInput>;
|
|
address: Scalars['String'];
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
domainName: Scalars['String'];
|
|
employees?: InputMaybe<Scalars['Int']>;
|
|
id: Scalars['String'];
|
|
name: Scalars['String'];
|
|
people?: InputMaybe<PersonCreateNestedManyWithoutCompanyInput>;
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type CompanyCreateNestedOneWithoutPeopleInput = {
|
|
connect?: InputMaybe<CompanyWhereUniqueInput>;
|
|
};
|
|
|
|
export type CompanyListRelationFilter = {
|
|
every?: InputMaybe<CompanyWhereInput>;
|
|
none?: InputMaybe<CompanyWhereInput>;
|
|
some?: InputMaybe<CompanyWhereInput>;
|
|
};
|
|
|
|
export type CompanyOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type CompanyOrderByWithRelationInput = {
|
|
accountOwner?: InputMaybe<UserOrderByWithRelationInput>;
|
|
accountOwnerId?: InputMaybe<SortOrder>;
|
|
address?: InputMaybe<SortOrder>;
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
domainName?: InputMaybe<SortOrder>;
|
|
employees?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
name?: InputMaybe<SortOrder>;
|
|
people?: InputMaybe<PersonOrderByRelationAggregateInput>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type CompanyRelationFilter = {
|
|
is?: InputMaybe<CompanyWhereInput>;
|
|
isNot?: InputMaybe<CompanyWhereInput>;
|
|
};
|
|
|
|
export enum CompanyScalarFieldEnum {
|
|
AccountOwnerId = 'accountOwnerId',
|
|
Address = 'address',
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
DomainName = 'domainName',
|
|
Employees = 'employees',
|
|
Id = 'id',
|
|
Name = 'name',
|
|
UpdatedAt = 'updatedAt',
|
|
WorkspaceId = 'workspaceId'
|
|
}
|
|
|
|
export type CompanyUpdateInput = {
|
|
accountOwner?: InputMaybe<UserUpdateOneWithoutCompaniesNestedInput>;
|
|
address?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
|
|
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
|
|
domainName?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
employees?: InputMaybe<NullableIntFieldUpdateOperationsInput>;
|
|
id?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
name?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
people?: InputMaybe<PersonUpdateManyWithoutCompanyNestedInput>;
|
|
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
|
|
};
|
|
|
|
export type CompanyUpdateOneWithoutPeopleNestedInput = {
|
|
connect?: InputMaybe<CompanyWhereUniqueInput>;
|
|
};
|
|
|
|
export type CompanyWhereInput = {
|
|
AND?: InputMaybe<Array<CompanyWhereInput>>;
|
|
NOT?: InputMaybe<Array<CompanyWhereInput>>;
|
|
OR?: InputMaybe<Array<CompanyWhereInput>>;
|
|
accountOwner?: InputMaybe<UserRelationFilter>;
|
|
accountOwnerId?: InputMaybe<StringNullableFilter>;
|
|
address?: InputMaybe<StringFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
domainName?: InputMaybe<StringFilter>;
|
|
employees?: InputMaybe<IntNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
name?: InputMaybe<StringFilter>;
|
|
people?: InputMaybe<PersonListRelationFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type CompanyWhereUniqueInput = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type DateTimeFieldUpdateOperationsInput = {
|
|
set?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type DateTimeFilter = {
|
|
equals?: InputMaybe<Scalars['DateTime']>;
|
|
gt?: InputMaybe<Scalars['DateTime']>;
|
|
gte?: InputMaybe<Scalars['DateTime']>;
|
|
in?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
lt?: InputMaybe<Scalars['DateTime']>;
|
|
lte?: InputMaybe<Scalars['DateTime']>;
|
|
not?: InputMaybe<NestedDateTimeFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
};
|
|
|
|
export type DateTimeNullableFilter = {
|
|
equals?: InputMaybe<Scalars['DateTime']>;
|
|
gt?: InputMaybe<Scalars['DateTime']>;
|
|
gte?: InputMaybe<Scalars['DateTime']>;
|
|
in?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
lt?: InputMaybe<Scalars['DateTime']>;
|
|
lte?: InputMaybe<Scalars['DateTime']>;
|
|
not?: InputMaybe<NestedDateTimeNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
};
|
|
|
|
export type EnumCommentableTypeFilter = {
|
|
equals?: InputMaybe<CommentableType>;
|
|
in?: InputMaybe<Array<CommentableType>>;
|
|
not?: InputMaybe<NestedEnumCommentableTypeFilter>;
|
|
notIn?: InputMaybe<Array<CommentableType>>;
|
|
};
|
|
|
|
export type EnumPipelineProgressableTypeFilter = {
|
|
equals?: InputMaybe<PipelineProgressableType>;
|
|
in?: InputMaybe<Array<PipelineProgressableType>>;
|
|
not?: InputMaybe<NestedEnumPipelineProgressableTypeFilter>;
|
|
notIn?: InputMaybe<Array<PipelineProgressableType>>;
|
|
};
|
|
|
|
export type IntNullableFilter = {
|
|
equals?: InputMaybe<Scalars['Int']>;
|
|
gt?: InputMaybe<Scalars['Int']>;
|
|
gte?: InputMaybe<Scalars['Int']>;
|
|
in?: InputMaybe<Array<Scalars['Int']>>;
|
|
lt?: InputMaybe<Scalars['Int']>;
|
|
lte?: InputMaybe<Scalars['Int']>;
|
|
not?: InputMaybe<NestedIntNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['Int']>>;
|
|
};
|
|
|
|
export type JsonNullableFilter = {
|
|
array_contains?: InputMaybe<Scalars['JSON']>;
|
|
array_ends_with?: InputMaybe<Scalars['JSON']>;
|
|
array_starts_with?: InputMaybe<Scalars['JSON']>;
|
|
equals?: InputMaybe<Scalars['JSON']>;
|
|
gt?: InputMaybe<Scalars['JSON']>;
|
|
gte?: InputMaybe<Scalars['JSON']>;
|
|
lt?: InputMaybe<Scalars['JSON']>;
|
|
lte?: InputMaybe<Scalars['JSON']>;
|
|
not?: InputMaybe<Scalars['JSON']>;
|
|
path?: InputMaybe<Array<Scalars['String']>>;
|
|
string_contains?: InputMaybe<Scalars['String']>;
|
|
string_ends_with?: InputMaybe<Scalars['String']>;
|
|
string_starts_with?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: 'Mutation';
|
|
createOneComment: Comment;
|
|
createOneCommentThread: CommentThread;
|
|
createOneCompany: Company;
|
|
createOnePerson: Person;
|
|
deleteManyCompany: AffectedRows;
|
|
deleteManyPerson: AffectedRows;
|
|
updateOneCompany?: Maybe<Company>;
|
|
updateOnePerson?: Maybe<Person>;
|
|
};
|
|
|
|
|
|
export type MutationCreateOneCommentArgs = {
|
|
data: CommentCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCreateOneCommentThreadArgs = {
|
|
data: CommentThreadCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCreateOneCompanyArgs = {
|
|
data: CompanyCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCreateOnePersonArgs = {
|
|
data: PersonCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationDeleteManyCompanyArgs = {
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
};
|
|
|
|
|
|
export type MutationDeleteManyPersonArgs = {
|
|
where?: InputMaybe<PersonWhereInput>;
|
|
};
|
|
|
|
|
|
export type MutationUpdateOneCompanyArgs = {
|
|
data: CompanyUpdateInput;
|
|
where: CompanyWhereUniqueInput;
|
|
};
|
|
|
|
|
|
export type MutationUpdateOnePersonArgs = {
|
|
data: PersonUpdateInput;
|
|
where: PersonWhereUniqueInput;
|
|
};
|
|
|
|
export type NestedBoolFilter = {
|
|
equals?: InputMaybe<Scalars['Boolean']>;
|
|
not?: InputMaybe<NestedBoolFilter>;
|
|
};
|
|
|
|
export type NestedDateTimeFilter = {
|
|
equals?: InputMaybe<Scalars['DateTime']>;
|
|
gt?: InputMaybe<Scalars['DateTime']>;
|
|
gte?: InputMaybe<Scalars['DateTime']>;
|
|
in?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
lt?: InputMaybe<Scalars['DateTime']>;
|
|
lte?: InputMaybe<Scalars['DateTime']>;
|
|
not?: InputMaybe<NestedDateTimeFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
};
|
|
|
|
export type NestedDateTimeNullableFilter = {
|
|
equals?: InputMaybe<Scalars['DateTime']>;
|
|
gt?: InputMaybe<Scalars['DateTime']>;
|
|
gte?: InputMaybe<Scalars['DateTime']>;
|
|
in?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
lt?: InputMaybe<Scalars['DateTime']>;
|
|
lte?: InputMaybe<Scalars['DateTime']>;
|
|
not?: InputMaybe<NestedDateTimeNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['DateTime']>>;
|
|
};
|
|
|
|
export type NestedEnumCommentableTypeFilter = {
|
|
equals?: InputMaybe<CommentableType>;
|
|
in?: InputMaybe<Array<CommentableType>>;
|
|
not?: InputMaybe<NestedEnumCommentableTypeFilter>;
|
|
notIn?: InputMaybe<Array<CommentableType>>;
|
|
};
|
|
|
|
export type NestedEnumPipelineProgressableTypeFilter = {
|
|
equals?: InputMaybe<PipelineProgressableType>;
|
|
in?: InputMaybe<Array<PipelineProgressableType>>;
|
|
not?: InputMaybe<NestedEnumPipelineProgressableTypeFilter>;
|
|
notIn?: InputMaybe<Array<PipelineProgressableType>>;
|
|
};
|
|
|
|
export type NestedIntNullableFilter = {
|
|
equals?: InputMaybe<Scalars['Int']>;
|
|
gt?: InputMaybe<Scalars['Int']>;
|
|
gte?: InputMaybe<Scalars['Int']>;
|
|
in?: InputMaybe<Array<Scalars['Int']>>;
|
|
lt?: InputMaybe<Scalars['Int']>;
|
|
lte?: InputMaybe<Scalars['Int']>;
|
|
not?: InputMaybe<NestedIntNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['Int']>>;
|
|
};
|
|
|
|
export type NestedStringFilter = {
|
|
contains?: InputMaybe<Scalars['String']>;
|
|
endsWith?: InputMaybe<Scalars['String']>;
|
|
equals?: InputMaybe<Scalars['String']>;
|
|
gt?: InputMaybe<Scalars['String']>;
|
|
gte?: InputMaybe<Scalars['String']>;
|
|
in?: InputMaybe<Array<Scalars['String']>>;
|
|
lt?: InputMaybe<Scalars['String']>;
|
|
lte?: InputMaybe<Scalars['String']>;
|
|
not?: InputMaybe<NestedStringFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
startsWith?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type NestedStringNullableFilter = {
|
|
contains?: InputMaybe<Scalars['String']>;
|
|
endsWith?: InputMaybe<Scalars['String']>;
|
|
equals?: InputMaybe<Scalars['String']>;
|
|
gt?: InputMaybe<Scalars['String']>;
|
|
gte?: InputMaybe<Scalars['String']>;
|
|
in?: InputMaybe<Array<Scalars['String']>>;
|
|
lt?: InputMaybe<Scalars['String']>;
|
|
lte?: InputMaybe<Scalars['String']>;
|
|
not?: InputMaybe<NestedStringNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
startsWith?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type NullableDateTimeFieldUpdateOperationsInput = {
|
|
set?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type NullableIntFieldUpdateOperationsInput = {
|
|
decrement?: InputMaybe<Scalars['Int']>;
|
|
divide?: InputMaybe<Scalars['Int']>;
|
|
increment?: InputMaybe<Scalars['Int']>;
|
|
multiply?: InputMaybe<Scalars['Int']>;
|
|
set?: InputMaybe<Scalars['Int']>;
|
|
};
|
|
|
|
export type Person = {
|
|
__typename?: 'Person';
|
|
_commentCount: Scalars['Int'];
|
|
city: Scalars['String'];
|
|
commentThreads: Array<CommentThread>;
|
|
comments: Array<Comment>;
|
|
company?: Maybe<Company>;
|
|
companyId?: Maybe<Scalars['String']>;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
email: Scalars['String'];
|
|
firstname: Scalars['String'];
|
|
id: Scalars['ID'];
|
|
lastname: Scalars['String'];
|
|
phone: Scalars['String'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type PersonCreateInput = {
|
|
city: Scalars['String'];
|
|
company?: InputMaybe<CompanyCreateNestedOneWithoutPeopleInput>;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
deletedAt?: InputMaybe<Scalars['DateTime']>;
|
|
email: Scalars['String'];
|
|
firstname: Scalars['String'];
|
|
id: Scalars['String'];
|
|
lastname: Scalars['String'];
|
|
phone: Scalars['String'];
|
|
updatedAt?: InputMaybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
export type PersonCreateNestedManyWithoutCompanyInput = {
|
|
connect?: InputMaybe<Array<PersonWhereUniqueInput>>;
|
|
};
|
|
|
|
export type PersonListRelationFilter = {
|
|
every?: InputMaybe<PersonWhereInput>;
|
|
none?: InputMaybe<PersonWhereInput>;
|
|
some?: InputMaybe<PersonWhereInput>;
|
|
};
|
|
|
|
export type PersonOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type PersonOrderByWithRelationInput = {
|
|
city?: InputMaybe<SortOrder>;
|
|
company?: InputMaybe<CompanyOrderByWithRelationInput>;
|
|
companyId?: InputMaybe<SortOrder>;
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
email?: InputMaybe<SortOrder>;
|
|
firstname?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
lastname?: InputMaybe<SortOrder>;
|
|
phone?: InputMaybe<SortOrder>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export enum PersonScalarFieldEnum {
|
|
City = 'city',
|
|
CompanyId = 'companyId',
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
Email = 'email',
|
|
Firstname = 'firstname',
|
|
Id = 'id',
|
|
Lastname = 'lastname',
|
|
Phone = 'phone',
|
|
UpdatedAt = 'updatedAt',
|
|
WorkspaceId = 'workspaceId'
|
|
}
|
|
|
|
export type PersonUpdateInput = {
|
|
city?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
company?: InputMaybe<CompanyUpdateOneWithoutPeopleNestedInput>;
|
|
createdAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
|
|
deletedAt?: InputMaybe<NullableDateTimeFieldUpdateOperationsInput>;
|
|
email?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
firstname?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
id?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
lastname?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
phone?: InputMaybe<StringFieldUpdateOperationsInput>;
|
|
updatedAt?: InputMaybe<DateTimeFieldUpdateOperationsInput>;
|
|
};
|
|
|
|
export type PersonUpdateManyWithoutCompanyNestedInput = {
|
|
connect?: InputMaybe<Array<PersonWhereUniqueInput>>;
|
|
};
|
|
|
|
export type PersonWhereInput = {
|
|
AND?: InputMaybe<Array<PersonWhereInput>>;
|
|
NOT?: InputMaybe<Array<PersonWhereInput>>;
|
|
OR?: InputMaybe<Array<PersonWhereInput>>;
|
|
city?: InputMaybe<StringFilter>;
|
|
company?: InputMaybe<CompanyRelationFilter>;
|
|
companyId?: InputMaybe<StringNullableFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
email?: InputMaybe<StringFilter>;
|
|
firstname?: InputMaybe<StringFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
lastname?: InputMaybe<StringFilter>;
|
|
phone?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type PersonWhereUniqueInput = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type Pipeline = {
|
|
__typename?: 'Pipeline';
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
icon: Scalars['String'];
|
|
id: Scalars['ID'];
|
|
name: Scalars['String'];
|
|
pipelineProgresses?: Maybe<Array<PipelineProgress>>;
|
|
pipelineStages?: Maybe<Array<PipelineStage>>;
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type PipelineOrderByWithRelationInput = {
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
icon?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
name?: InputMaybe<SortOrder>;
|
|
pipelineProgresses?: InputMaybe<PipelineProgressOrderByRelationAggregateInput>;
|
|
pipelineStages?: InputMaybe<PipelineStageOrderByRelationAggregateInput>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type PipelineProgress = {
|
|
__typename?: 'PipelineProgress';
|
|
associableId: Scalars['String'];
|
|
associableType: PipelineProgressableType;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
pipeline: Pipeline;
|
|
pipelineId: Scalars['String'];
|
|
pipelineStage: PipelineStage;
|
|
pipelineStageId: Scalars['String'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type PipelineProgressListRelationFilter = {
|
|
every?: InputMaybe<PipelineProgressWhereInput>;
|
|
none?: InputMaybe<PipelineProgressWhereInput>;
|
|
some?: InputMaybe<PipelineProgressWhereInput>;
|
|
};
|
|
|
|
export type PipelineProgressOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type PipelineProgressWhereInput = {
|
|
AND?: InputMaybe<Array<PipelineProgressWhereInput>>;
|
|
NOT?: InputMaybe<Array<PipelineProgressWhereInput>>;
|
|
OR?: InputMaybe<Array<PipelineProgressWhereInput>>;
|
|
associableId?: InputMaybe<StringFilter>;
|
|
associableType?: InputMaybe<EnumPipelineProgressableTypeFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
pipeline?: InputMaybe<PipelineRelationFilter>;
|
|
pipelineId?: InputMaybe<StringFilter>;
|
|
pipelineStage?: InputMaybe<PipelineStageRelationFilter>;
|
|
pipelineStageId?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export enum PipelineProgressableType {
|
|
Company = 'Company',
|
|
Person = 'Person'
|
|
}
|
|
|
|
export type PipelineRelationFilter = {
|
|
is?: InputMaybe<PipelineWhereInput>;
|
|
isNot?: InputMaybe<PipelineWhereInput>;
|
|
};
|
|
|
|
export enum PipelineScalarFieldEnum {
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
Icon = 'icon',
|
|
Id = 'id',
|
|
Name = 'name',
|
|
UpdatedAt = 'updatedAt',
|
|
WorkspaceId = 'workspaceId'
|
|
}
|
|
|
|
export type PipelineStage = {
|
|
__typename?: 'PipelineStage';
|
|
color: Scalars['String'];
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
name: Scalars['String'];
|
|
pipeline: Pipeline;
|
|
pipelineId: Scalars['String'];
|
|
pipelineProgresses?: Maybe<Array<PipelineProgress>>;
|
|
type: Scalars['String'];
|
|
updatedAt: Scalars['DateTime'];
|
|
};
|
|
|
|
export type PipelineStageListRelationFilter = {
|
|
every?: InputMaybe<PipelineStageWhereInput>;
|
|
none?: InputMaybe<PipelineStageWhereInput>;
|
|
some?: InputMaybe<PipelineStageWhereInput>;
|
|
};
|
|
|
|
export type PipelineStageOrderByRelationAggregateInput = {
|
|
_count?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type PipelineStageOrderByWithRelationInput = {
|
|
color?: InputMaybe<SortOrder>;
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
name?: InputMaybe<SortOrder>;
|
|
pipeline?: InputMaybe<PipelineOrderByWithRelationInput>;
|
|
pipelineId?: InputMaybe<SortOrder>;
|
|
pipelineProgresses?: InputMaybe<PipelineProgressOrderByRelationAggregateInput>;
|
|
type?: InputMaybe<SortOrder>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type PipelineStageRelationFilter = {
|
|
is?: InputMaybe<PipelineStageWhereInput>;
|
|
isNot?: InputMaybe<PipelineStageWhereInput>;
|
|
};
|
|
|
|
export enum PipelineStageScalarFieldEnum {
|
|
Color = 'color',
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
Id = 'id',
|
|
Name = 'name',
|
|
PipelineId = 'pipelineId',
|
|
Type = 'type',
|
|
UpdatedAt = 'updatedAt',
|
|
WorkspaceId = 'workspaceId'
|
|
}
|
|
|
|
export type PipelineStageWhereInput = {
|
|
AND?: InputMaybe<Array<PipelineStageWhereInput>>;
|
|
NOT?: InputMaybe<Array<PipelineStageWhereInput>>;
|
|
OR?: InputMaybe<Array<PipelineStageWhereInput>>;
|
|
color?: InputMaybe<StringFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
name?: InputMaybe<StringFilter>;
|
|
pipeline?: InputMaybe<PipelineRelationFilter>;
|
|
pipelineId?: InputMaybe<StringFilter>;
|
|
pipelineProgresses?: InputMaybe<PipelineProgressListRelationFilter>;
|
|
type?: InputMaybe<StringFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type PipelineStageWhereUniqueInput = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type PipelineWhereInput = {
|
|
AND?: InputMaybe<Array<PipelineWhereInput>>;
|
|
NOT?: InputMaybe<Array<PipelineWhereInput>>;
|
|
OR?: InputMaybe<Array<PipelineWhereInput>>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
icon?: InputMaybe<StringFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
name?: InputMaybe<StringFilter>;
|
|
pipelineProgresses?: InputMaybe<PipelineProgressListRelationFilter>;
|
|
pipelineStages?: InputMaybe<PipelineStageListRelationFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type PipelineWhereUniqueInput = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: 'Query';
|
|
findManyCommentThreads: Array<CommentThread>;
|
|
findManyCompany: Array<Company>;
|
|
findManyPerson: Array<Person>;
|
|
findManyPipeline: Array<Pipeline>;
|
|
findManyPipelineStage: Array<PipelineStage>;
|
|
findManyUser: Array<User>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyCommentThreadsArgs = {
|
|
cursor?: InputMaybe<CommentThreadWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<CommentThreadScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<CommentThreadOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<CommentThreadWhereInput>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyCompanyArgs = {
|
|
cursor?: InputMaybe<CompanyWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<CompanyScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<CompanyOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyPersonArgs = {
|
|
cursor?: InputMaybe<PersonWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<PersonScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<PersonOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<PersonWhereInput>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyPipelineArgs = {
|
|
cursor?: InputMaybe<PipelineWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<PipelineScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<PipelineOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<PipelineWhereInput>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyPipelineStageArgs = {
|
|
cursor?: InputMaybe<PipelineStageWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<PipelineStageScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<PipelineStageOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<PipelineStageWhereInput>;
|
|
};
|
|
|
|
|
|
export type QueryFindManyUserArgs = {
|
|
cursor?: InputMaybe<UserWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<UserScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<UserOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<UserWhereInput>;
|
|
};
|
|
|
|
export enum QueryMode {
|
|
Default = 'default',
|
|
Insensitive = 'insensitive'
|
|
}
|
|
|
|
export enum SortOrder {
|
|
Asc = 'asc',
|
|
Desc = 'desc'
|
|
}
|
|
|
|
export type StringFieldUpdateOperationsInput = {
|
|
set?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type StringFilter = {
|
|
contains?: InputMaybe<Scalars['String']>;
|
|
endsWith?: InputMaybe<Scalars['String']>;
|
|
equals?: InputMaybe<Scalars['String']>;
|
|
gt?: InputMaybe<Scalars['String']>;
|
|
gte?: InputMaybe<Scalars['String']>;
|
|
in?: InputMaybe<Array<Scalars['String']>>;
|
|
lt?: InputMaybe<Scalars['String']>;
|
|
lte?: InputMaybe<Scalars['String']>;
|
|
mode?: InputMaybe<QueryMode>;
|
|
not?: InputMaybe<NestedStringFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
startsWith?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type StringNullableFilter = {
|
|
contains?: InputMaybe<Scalars['String']>;
|
|
endsWith?: InputMaybe<Scalars['String']>;
|
|
equals?: InputMaybe<Scalars['String']>;
|
|
gt?: InputMaybe<Scalars['String']>;
|
|
gte?: InputMaybe<Scalars['String']>;
|
|
in?: InputMaybe<Array<Scalars['String']>>;
|
|
lt?: InputMaybe<Scalars['String']>;
|
|
lte?: InputMaybe<Scalars['String']>;
|
|
mode?: InputMaybe<QueryMode>;
|
|
not?: InputMaybe<NestedStringNullableFilter>;
|
|
notIn?: InputMaybe<Array<Scalars['String']>>;
|
|
startsWith?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type User = {
|
|
__typename?: 'User';
|
|
avatarUrl?: Maybe<Scalars['String']>;
|
|
comments?: Maybe<Array<Comment>>;
|
|
companies?: Maybe<Array<Company>>;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
disabled: Scalars['Boolean'];
|
|
displayName: Scalars['String'];
|
|
email: Scalars['String'];
|
|
emailVerified: Scalars['Boolean'];
|
|
id: Scalars['ID'];
|
|
lastSeen?: Maybe<Scalars['DateTime']>;
|
|
locale: Scalars['String'];
|
|
metadata?: Maybe<Scalars['JSON']>;
|
|
passwordHash?: Maybe<Scalars['String']>;
|
|
phoneNumber?: Maybe<Scalars['String']>;
|
|
updatedAt: Scalars['DateTime'];
|
|
workspaceMember?: Maybe<WorkspaceMember>;
|
|
};
|
|
|
|
|
|
export type UserCompaniesArgs = {
|
|
cursor?: InputMaybe<CompanyWhereUniqueInput>;
|
|
distinct?: InputMaybe<Array<CompanyScalarFieldEnum>>;
|
|
orderBy?: InputMaybe<Array<CompanyOrderByWithRelationInput>>;
|
|
skip?: InputMaybe<Scalars['Int']>;
|
|
take?: InputMaybe<Scalars['Int']>;
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
};
|
|
|
|
export type UserCreateNestedOneWithoutCommentsInput = {
|
|
connect?: InputMaybe<UserWhereUniqueInput>;
|
|
};
|
|
|
|
export type UserCreateNestedOneWithoutCompaniesInput = {
|
|
connect?: InputMaybe<UserWhereUniqueInput>;
|
|
};
|
|
|
|
export type UserOrderByWithRelationInput = {
|
|
avatarUrl?: InputMaybe<SortOrder>;
|
|
comments?: InputMaybe<CommentOrderByRelationAggregateInput>;
|
|
companies?: InputMaybe<CompanyOrderByRelationAggregateInput>;
|
|
createdAt?: InputMaybe<SortOrder>;
|
|
deletedAt?: InputMaybe<SortOrder>;
|
|
disabled?: InputMaybe<SortOrder>;
|
|
displayName?: InputMaybe<SortOrder>;
|
|
email?: InputMaybe<SortOrder>;
|
|
emailVerified?: InputMaybe<SortOrder>;
|
|
id?: InputMaybe<SortOrder>;
|
|
lastSeen?: InputMaybe<SortOrder>;
|
|
locale?: InputMaybe<SortOrder>;
|
|
metadata?: InputMaybe<SortOrder>;
|
|
passwordHash?: InputMaybe<SortOrder>;
|
|
phoneNumber?: InputMaybe<SortOrder>;
|
|
updatedAt?: InputMaybe<SortOrder>;
|
|
};
|
|
|
|
export type UserRelationFilter = {
|
|
is?: InputMaybe<UserWhereInput>;
|
|
isNot?: InputMaybe<UserWhereInput>;
|
|
};
|
|
|
|
export enum UserScalarFieldEnum {
|
|
AvatarUrl = 'avatarUrl',
|
|
CreatedAt = 'createdAt',
|
|
DeletedAt = 'deletedAt',
|
|
Disabled = 'disabled',
|
|
DisplayName = 'displayName',
|
|
Email = 'email',
|
|
EmailVerified = 'emailVerified',
|
|
Id = 'id',
|
|
LastSeen = 'lastSeen',
|
|
Locale = 'locale',
|
|
Metadata = 'metadata',
|
|
PasswordHash = 'passwordHash',
|
|
PhoneNumber = 'phoneNumber',
|
|
UpdatedAt = 'updatedAt'
|
|
}
|
|
|
|
export type UserUpdateOneWithoutCompaniesNestedInput = {
|
|
connect?: InputMaybe<UserWhereUniqueInput>;
|
|
};
|
|
|
|
export type UserWhereInput = {
|
|
AND?: InputMaybe<Array<UserWhereInput>>;
|
|
NOT?: InputMaybe<Array<UserWhereInput>>;
|
|
OR?: InputMaybe<Array<UserWhereInput>>;
|
|
avatarUrl?: InputMaybe<StringNullableFilter>;
|
|
comments?: InputMaybe<CommentListRelationFilter>;
|
|
companies?: InputMaybe<CompanyListRelationFilter>;
|
|
createdAt?: InputMaybe<DateTimeFilter>;
|
|
deletedAt?: InputMaybe<DateTimeNullableFilter>;
|
|
disabled?: InputMaybe<BoolFilter>;
|
|
displayName?: InputMaybe<StringFilter>;
|
|
email?: InputMaybe<StringFilter>;
|
|
emailVerified?: InputMaybe<BoolFilter>;
|
|
id?: InputMaybe<StringFilter>;
|
|
lastSeen?: InputMaybe<DateTimeNullableFilter>;
|
|
locale?: InputMaybe<StringFilter>;
|
|
metadata?: InputMaybe<JsonNullableFilter>;
|
|
passwordHash?: InputMaybe<StringNullableFilter>;
|
|
phoneNumber?: InputMaybe<StringNullableFilter>;
|
|
updatedAt?: InputMaybe<DateTimeFilter>;
|
|
};
|
|
|
|
export type UserWhereUniqueInput = {
|
|
email?: InputMaybe<Scalars['String']>;
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type Workspace = {
|
|
__typename?: 'Workspace';
|
|
commentThreads?: Maybe<Array<CommentThread>>;
|
|
comments?: Maybe<Array<Comment>>;
|
|
companies?: Maybe<Array<Company>>;
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
displayName: Scalars['String'];
|
|
domainName: Scalars['String'];
|
|
id: Scalars['ID'];
|
|
logo?: Maybe<Scalars['String']>;
|
|
people?: Maybe<Array<Person>>;
|
|
pipelineStages?: Maybe<Array<PipelineStage>>;
|
|
pipelines?: Maybe<Array<Pipeline>>;
|
|
updatedAt: Scalars['DateTime'];
|
|
workspaceMember?: Maybe<Array<WorkspaceMember>>;
|
|
};
|
|
|
|
export type WorkspaceMember = {
|
|
__typename?: 'WorkspaceMember';
|
|
createdAt: Scalars['DateTime'];
|
|
deletedAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['ID'];
|
|
updatedAt: Scalars['DateTime'];
|
|
user: User;
|
|
userId: Scalars['String'];
|
|
workspace: Workspace;
|
|
};
|
|
|
|
export type GetCompanyCountsQueryVariables = Exact<{
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
}>;
|
|
|
|
|
|
export type GetCompanyCountsQuery = { __typename?: 'Query', companies: Array<{ __typename?: 'Company', commentsCount: number }> };
|
|
|
|
export type GetPeopleCountsQueryVariables = Exact<{
|
|
where?: InputMaybe<PersonWhereInput>;
|
|
}>;
|
|
|
|
|
|
export type GetPeopleCountsQuery = { __typename?: 'Query', people: Array<{ __typename?: 'Person', commentsCount: number }> };
|
|
|
|
export type GetCommentThreadsByTargetsQueryVariables = Exact<{
|
|
commentThreadTargetIds: Array<Scalars['String']> | Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetCommentThreadsByTargetsQuery = { __typename?: 'Query', findManyCommentThreads: Array<{ __typename?: 'CommentThread', id: string, comments?: Array<{ __typename?: 'Comment', id: string, body: string, createdAt: any, updatedAt: any, author: { __typename?: 'User', id: string, displayName: string, avatarUrl?: string | null } }> | null }> };
|
|
|
|
export type GetCompaniesQueryVariables = Exact<{
|
|
orderBy?: InputMaybe<Array<CompanyOrderByWithRelationInput> | CompanyOrderByWithRelationInput>;
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
}>;
|
|
|
|
|
|
export type GetCompaniesQuery = { __typename?: 'Query', companies: Array<{ __typename?: 'Company', id: string, domainName: string, name: string, createdAt: any, address: string, employees?: number | null, accountOwner?: { __typename?: 'User', id: string, email: string, displayName: string } | null }> };
|
|
|
|
export type UpdateCompanyMutationVariables = Exact<{
|
|
id?: InputMaybe<Scalars['String']>;
|
|
name?: InputMaybe<Scalars['String']>;
|
|
domainName?: InputMaybe<Scalars['String']>;
|
|
accountOwnerId?: InputMaybe<Scalars['String']>;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
address?: InputMaybe<Scalars['String']>;
|
|
employees?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type UpdateCompanyMutation = { __typename?: 'Mutation', updateOneCompany?: { __typename?: 'Company', address: string, createdAt: any, domainName: string, employees?: number | null, id: string, name: string, accountOwner?: { __typename?: 'User', id: string, email: string, displayName: string } | null } | null };
|
|
|
|
export type InsertCompanyMutationVariables = Exact<{
|
|
id: Scalars['String'];
|
|
name: Scalars['String'];
|
|
domainName: Scalars['String'];
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
address: Scalars['String'];
|
|
employees?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type InsertCompanyMutation = { __typename?: 'Mutation', createOneCompany: { __typename?: 'Company', address: string, createdAt: any, domainName: string, employees?: number | null, id: string, name: string } };
|
|
|
|
export type DeleteCompaniesMutationVariables = Exact<{
|
|
ids?: InputMaybe<Array<Scalars['String']> | Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type DeleteCompaniesMutation = { __typename?: 'Mutation', deleteManyCompany: { __typename?: 'AffectedRows', count: number } };
|
|
|
|
export type GetPeopleQueryVariables = Exact<{
|
|
orderBy?: InputMaybe<Array<PersonOrderByWithRelationInput> | PersonOrderByWithRelationInput>;
|
|
where?: InputMaybe<PersonWhereInput>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type GetPeopleQuery = { __typename?: 'Query', people: Array<{ __typename?: 'Person', id: string, phone: string, email: string, city: string, firstname: string, lastname: string, createdAt: any, company?: { __typename?: 'Company', id: string, name: string, domainName: string } | null }> };
|
|
|
|
export type UpdatePeopleMutationVariables = Exact<{
|
|
id?: InputMaybe<Scalars['String']>;
|
|
firstname?: InputMaybe<Scalars['String']>;
|
|
lastname?: InputMaybe<Scalars['String']>;
|
|
phone?: InputMaybe<Scalars['String']>;
|
|
city?: InputMaybe<Scalars['String']>;
|
|
companyId?: InputMaybe<Scalars['String']>;
|
|
email?: InputMaybe<Scalars['String']>;
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
}>;
|
|
|
|
|
|
export type UpdatePeopleMutation = { __typename?: 'Mutation', updateOnePerson?: { __typename?: 'Person', city: string, email: string, firstname: string, id: string, lastname: string, phone: string, createdAt: any, company?: { __typename?: 'Company', domainName: string, name: string, id: string } | null } | null };
|
|
|
|
export type InsertPersonMutationVariables = Exact<{
|
|
id: Scalars['String'];
|
|
firstname: Scalars['String'];
|
|
lastname: Scalars['String'];
|
|
phone: Scalars['String'];
|
|
city: Scalars['String'];
|
|
email: Scalars['String'];
|
|
createdAt?: InputMaybe<Scalars['DateTime']>;
|
|
}>;
|
|
|
|
|
|
export type InsertPersonMutation = { __typename?: 'Mutation', createOnePerson: { __typename?: 'Person', city: string, email: string, firstname: string, id: string, lastname: string, phone: string, createdAt: any, company?: { __typename?: 'Company', domainName: string, name: string, id: string } | null } };
|
|
|
|
export type DeletePeopleMutationVariables = Exact<{
|
|
ids?: InputMaybe<Array<Scalars['String']> | Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type DeletePeopleMutation = { __typename?: 'Mutation', deleteManyPerson: { __typename?: 'AffectedRows', count: number } };
|
|
|
|
export type SearchPeopleQueryQueryVariables = Exact<{
|
|
where?: InputMaybe<PersonWhereInput>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type SearchPeopleQueryQuery = { __typename?: 'Query', searchResults: Array<{ __typename?: 'Person', id: string, phone: string, email: string, city: string, firstname: string, lastname: string, createdAt: any }> };
|
|
|
|
export type SearchUserQueryQueryVariables = Exact<{
|
|
where?: InputMaybe<UserWhereInput>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type SearchUserQueryQuery = { __typename?: 'Query', searchResults: Array<{ __typename?: 'User', id: string, email: string, displayName: string }> };
|
|
|
|
export type EmptyQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type EmptyQueryQuery = { __typename?: 'Query', searchResults: Array<{ __typename?: 'User', id: string }> };
|
|
|
|
export type SearchCompanyQueryQueryVariables = Exact<{
|
|
where?: InputMaybe<CompanyWhereInput>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
}>;
|
|
|
|
|
|
export type SearchCompanyQueryQuery = { __typename?: 'Query', searchResults: Array<{ __typename?: 'Company', id: string, name: string, domainName: string }> };
|
|
|
|
export type GetCurrentUserQueryVariables = Exact<{
|
|
uuid?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetCurrentUserQuery = { __typename?: 'Query', users: Array<{ __typename?: 'User', id: string, email: string, displayName: string, workspaceMember?: { __typename?: 'WorkspaceMember', workspace: { __typename?: 'Workspace', id: string, domainName: string, displayName: string, logo?: string | null } } | null }> };
|
|
|
|
export type GetUsersQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type GetUsersQuery = { __typename?: 'Query', findManyUser: Array<{ __typename?: 'User', id: string }> };
|
|
|
|
|
|
export const GetCompanyCountsDocument = gql`
|
|
query GetCompanyCounts($where: CompanyWhereInput) {
|
|
companies: findManyCompany(where: $where) {
|
|
commentsCount: _commentCount
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetCompanyCountsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetCompanyCountsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetCompanyCountsQuery` 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 } = useGetCompanyCountsQuery({
|
|
* variables: {
|
|
* where: // value for 'where'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetCompanyCountsQuery(baseOptions?: Apollo.QueryHookOptions<GetCompanyCountsQuery, GetCompanyCountsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetCompanyCountsQuery, GetCompanyCountsQueryVariables>(GetCompanyCountsDocument, options);
|
|
}
|
|
export function useGetCompanyCountsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCompanyCountsQuery, GetCompanyCountsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetCompanyCountsQuery, GetCompanyCountsQueryVariables>(GetCompanyCountsDocument, options);
|
|
}
|
|
export type GetCompanyCountsQueryHookResult = ReturnType<typeof useGetCompanyCountsQuery>;
|
|
export type GetCompanyCountsLazyQueryHookResult = ReturnType<typeof useGetCompanyCountsLazyQuery>;
|
|
export type GetCompanyCountsQueryResult = Apollo.QueryResult<GetCompanyCountsQuery, GetCompanyCountsQueryVariables>;
|
|
export const GetPeopleCountsDocument = gql`
|
|
query GetPeopleCounts($where: PersonWhereInput) {
|
|
people: findManyPerson(where: $where) {
|
|
commentsCount: _commentCount
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetPeopleCountsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetPeopleCountsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetPeopleCountsQuery` 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 } = useGetPeopleCountsQuery({
|
|
* variables: {
|
|
* where: // value for 'where'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetPeopleCountsQuery(baseOptions?: Apollo.QueryHookOptions<GetPeopleCountsQuery, GetPeopleCountsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetPeopleCountsQuery, GetPeopleCountsQueryVariables>(GetPeopleCountsDocument, options);
|
|
}
|
|
export function useGetPeopleCountsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPeopleCountsQuery, GetPeopleCountsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetPeopleCountsQuery, GetPeopleCountsQueryVariables>(GetPeopleCountsDocument, options);
|
|
}
|
|
export type GetPeopleCountsQueryHookResult = ReturnType<typeof useGetPeopleCountsQuery>;
|
|
export type GetPeopleCountsLazyQueryHookResult = ReturnType<typeof useGetPeopleCountsLazyQuery>;
|
|
export type GetPeopleCountsQueryResult = Apollo.QueryResult<GetPeopleCountsQuery, GetPeopleCountsQueryVariables>;
|
|
export const GetCommentThreadsByTargetsDocument = gql`
|
|
query GetCommentThreadsByTargets($commentThreadTargetIds: [String!]!) {
|
|
findManyCommentThreads(
|
|
where: {commentThreadTargets: {some: {commentableId: {in: $commentThreadTargetIds}}}}
|
|
) {
|
|
id
|
|
comments {
|
|
id
|
|
body
|
|
createdAt
|
|
updatedAt
|
|
author {
|
|
id
|
|
displayName
|
|
avatarUrl
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetCommentThreadsByTargetsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetCommentThreadsByTargetsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetCommentThreadsByTargetsQuery` 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 } = useGetCommentThreadsByTargetsQuery({
|
|
* variables: {
|
|
* commentThreadTargetIds: // value for 'commentThreadTargetIds'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetCommentThreadsByTargetsQuery(baseOptions: Apollo.QueryHookOptions<GetCommentThreadsByTargetsQuery, GetCommentThreadsByTargetsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetCommentThreadsByTargetsQuery, GetCommentThreadsByTargetsQueryVariables>(GetCommentThreadsByTargetsDocument, options);
|
|
}
|
|
export function useGetCommentThreadsByTargetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCommentThreadsByTargetsQuery, GetCommentThreadsByTargetsQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetCommentThreadsByTargetsQuery, GetCommentThreadsByTargetsQueryVariables>(GetCommentThreadsByTargetsDocument, options);
|
|
}
|
|
export type GetCommentThreadsByTargetsQueryHookResult = ReturnType<typeof useGetCommentThreadsByTargetsQuery>;
|
|
export type GetCommentThreadsByTargetsLazyQueryHookResult = ReturnType<typeof useGetCommentThreadsByTargetsLazyQuery>;
|
|
export type GetCommentThreadsByTargetsQueryResult = Apollo.QueryResult<GetCommentThreadsByTargetsQuery, GetCommentThreadsByTargetsQueryVariables>;
|
|
export const GetCompaniesDocument = gql`
|
|
query GetCompanies($orderBy: [CompanyOrderByWithRelationInput!], $where: CompanyWhereInput) {
|
|
companies: findManyCompany(orderBy: $orderBy, where: $where) {
|
|
id
|
|
domainName
|
|
name
|
|
createdAt
|
|
address
|
|
employees
|
|
accountOwner {
|
|
id
|
|
email
|
|
displayName
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetCompaniesQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetCompaniesQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetCompaniesQuery` 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 } = useGetCompaniesQuery({
|
|
* variables: {
|
|
* orderBy: // value for 'orderBy'
|
|
* where: // value for 'where'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetCompaniesQuery(baseOptions?: Apollo.QueryHookOptions<GetCompaniesQuery, GetCompaniesQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetCompaniesQuery, GetCompaniesQueryVariables>(GetCompaniesDocument, options);
|
|
}
|
|
export function useGetCompaniesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCompaniesQuery, GetCompaniesQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetCompaniesQuery, GetCompaniesQueryVariables>(GetCompaniesDocument, options);
|
|
}
|
|
export type GetCompaniesQueryHookResult = ReturnType<typeof useGetCompaniesQuery>;
|
|
export type GetCompaniesLazyQueryHookResult = ReturnType<typeof useGetCompaniesLazyQuery>;
|
|
export type GetCompaniesQueryResult = Apollo.QueryResult<GetCompaniesQuery, GetCompaniesQueryVariables>;
|
|
export const UpdateCompanyDocument = gql`
|
|
mutation UpdateCompany($id: String, $name: String, $domainName: String, $accountOwnerId: String, $createdAt: DateTime, $address: String, $employees: Int) {
|
|
updateOneCompany(
|
|
where: {id: $id}
|
|
data: {accountOwner: {connect: {id: $accountOwnerId}}, address: {set: $address}, domainName: {set: $domainName}, employees: {set: $employees}, name: {set: $name}, createdAt: {set: $createdAt}}
|
|
) {
|
|
accountOwner {
|
|
id
|
|
email
|
|
displayName
|
|
}
|
|
address
|
|
createdAt
|
|
domainName
|
|
employees
|
|
id
|
|
name
|
|
}
|
|
}
|
|
`;
|
|
export type UpdateCompanyMutationFn = Apollo.MutationFunction<UpdateCompanyMutation, UpdateCompanyMutationVariables>;
|
|
|
|
/**
|
|
* __useUpdateCompanyMutation__
|
|
*
|
|
* To run a mutation, you first call `useUpdateCompanyMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useUpdateCompanyMutation` 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 [updateCompanyMutation, { data, loading, error }] = useUpdateCompanyMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* name: // value for 'name'
|
|
* domainName: // value for 'domainName'
|
|
* accountOwnerId: // value for 'accountOwnerId'
|
|
* createdAt: // value for 'createdAt'
|
|
* address: // value for 'address'
|
|
* employees: // value for 'employees'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useUpdateCompanyMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCompanyMutation, UpdateCompanyMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<UpdateCompanyMutation, UpdateCompanyMutationVariables>(UpdateCompanyDocument, options);
|
|
}
|
|
export type UpdateCompanyMutationHookResult = ReturnType<typeof useUpdateCompanyMutation>;
|
|
export type UpdateCompanyMutationResult = Apollo.MutationResult<UpdateCompanyMutation>;
|
|
export type UpdateCompanyMutationOptions = Apollo.BaseMutationOptions<UpdateCompanyMutation, UpdateCompanyMutationVariables>;
|
|
export const InsertCompanyDocument = gql`
|
|
mutation InsertCompany($id: String!, $name: String!, $domainName: String!, $createdAt: DateTime, $address: String!, $employees: Int) {
|
|
createOneCompany(
|
|
data: {id: $id, name: $name, domainName: $domainName, createdAt: $createdAt, address: $address, employees: $employees}
|
|
) {
|
|
address
|
|
createdAt
|
|
domainName
|
|
employees
|
|
id
|
|
name
|
|
}
|
|
}
|
|
`;
|
|
export type InsertCompanyMutationFn = Apollo.MutationFunction<InsertCompanyMutation, InsertCompanyMutationVariables>;
|
|
|
|
/**
|
|
* __useInsertCompanyMutation__
|
|
*
|
|
* To run a mutation, you first call `useInsertCompanyMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useInsertCompanyMutation` 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 [insertCompanyMutation, { data, loading, error }] = useInsertCompanyMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* name: // value for 'name'
|
|
* domainName: // value for 'domainName'
|
|
* createdAt: // value for 'createdAt'
|
|
* address: // value for 'address'
|
|
* employees: // value for 'employees'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useInsertCompanyMutation(baseOptions?: Apollo.MutationHookOptions<InsertCompanyMutation, InsertCompanyMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<InsertCompanyMutation, InsertCompanyMutationVariables>(InsertCompanyDocument, options);
|
|
}
|
|
export type InsertCompanyMutationHookResult = ReturnType<typeof useInsertCompanyMutation>;
|
|
export type InsertCompanyMutationResult = Apollo.MutationResult<InsertCompanyMutation>;
|
|
export type InsertCompanyMutationOptions = Apollo.BaseMutationOptions<InsertCompanyMutation, InsertCompanyMutationVariables>;
|
|
export const DeleteCompaniesDocument = gql`
|
|
mutation DeleteCompanies($ids: [String!]) {
|
|
deleteManyCompany(where: {id: {in: $ids}}) {
|
|
count
|
|
}
|
|
}
|
|
`;
|
|
export type DeleteCompaniesMutationFn = Apollo.MutationFunction<DeleteCompaniesMutation, DeleteCompaniesMutationVariables>;
|
|
|
|
/**
|
|
* __useDeleteCompaniesMutation__
|
|
*
|
|
* To run a mutation, you first call `useDeleteCompaniesMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useDeleteCompaniesMutation` 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 [deleteCompaniesMutation, { data, loading, error }] = useDeleteCompaniesMutation({
|
|
* variables: {
|
|
* ids: // value for 'ids'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useDeleteCompaniesMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCompaniesMutation, DeleteCompaniesMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<DeleteCompaniesMutation, DeleteCompaniesMutationVariables>(DeleteCompaniesDocument, options);
|
|
}
|
|
export type DeleteCompaniesMutationHookResult = ReturnType<typeof useDeleteCompaniesMutation>;
|
|
export type DeleteCompaniesMutationResult = Apollo.MutationResult<DeleteCompaniesMutation>;
|
|
export type DeleteCompaniesMutationOptions = Apollo.BaseMutationOptions<DeleteCompaniesMutation, DeleteCompaniesMutationVariables>;
|
|
export const GetPeopleDocument = gql`
|
|
query GetPeople($orderBy: [PersonOrderByWithRelationInput!], $where: PersonWhereInput, $limit: Int) {
|
|
people: findManyPerson(orderBy: $orderBy, where: $where, take: $limit) {
|
|
id
|
|
phone
|
|
email
|
|
city
|
|
firstname
|
|
lastname
|
|
createdAt
|
|
company {
|
|
id
|
|
name
|
|
domainName
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetPeopleQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetPeopleQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetPeopleQuery` 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 } = useGetPeopleQuery({
|
|
* variables: {
|
|
* orderBy: // value for 'orderBy'
|
|
* where: // value for 'where'
|
|
* limit: // value for 'limit'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetPeopleQuery(baseOptions?: Apollo.QueryHookOptions<GetPeopleQuery, GetPeopleQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetPeopleQuery, GetPeopleQueryVariables>(GetPeopleDocument, options);
|
|
}
|
|
export function useGetPeopleLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPeopleQuery, GetPeopleQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetPeopleQuery, GetPeopleQueryVariables>(GetPeopleDocument, options);
|
|
}
|
|
export type GetPeopleQueryHookResult = ReturnType<typeof useGetPeopleQuery>;
|
|
export type GetPeopleLazyQueryHookResult = ReturnType<typeof useGetPeopleLazyQuery>;
|
|
export type GetPeopleQueryResult = Apollo.QueryResult<GetPeopleQuery, GetPeopleQueryVariables>;
|
|
export const UpdatePeopleDocument = gql`
|
|
mutation UpdatePeople($id: String, $firstname: String, $lastname: String, $phone: String, $city: String, $companyId: String, $email: String, $createdAt: DateTime) {
|
|
updateOnePerson(
|
|
where: {id: $id}
|
|
data: {city: {set: $city}, company: {connect: {id: $companyId}}, email: {set: $email}, firstname: {set: $firstname}, id: {set: $id}, lastname: {set: $lastname}, phone: {set: $phone}, createdAt: {set: $createdAt}}
|
|
) {
|
|
city
|
|
company {
|
|
domainName
|
|
name
|
|
id
|
|
}
|
|
email
|
|
firstname
|
|
id
|
|
lastname
|
|
phone
|
|
createdAt
|
|
}
|
|
}
|
|
`;
|
|
export type UpdatePeopleMutationFn = Apollo.MutationFunction<UpdatePeopleMutation, UpdatePeopleMutationVariables>;
|
|
|
|
/**
|
|
* __useUpdatePeopleMutation__
|
|
*
|
|
* To run a mutation, you first call `useUpdatePeopleMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useUpdatePeopleMutation` 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 [updatePeopleMutation, { data, loading, error }] = useUpdatePeopleMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* firstname: // value for 'firstname'
|
|
* lastname: // value for 'lastname'
|
|
* phone: // value for 'phone'
|
|
* city: // value for 'city'
|
|
* companyId: // value for 'companyId'
|
|
* email: // value for 'email'
|
|
* createdAt: // value for 'createdAt'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useUpdatePeopleMutation(baseOptions?: Apollo.MutationHookOptions<UpdatePeopleMutation, UpdatePeopleMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<UpdatePeopleMutation, UpdatePeopleMutationVariables>(UpdatePeopleDocument, options);
|
|
}
|
|
export type UpdatePeopleMutationHookResult = ReturnType<typeof useUpdatePeopleMutation>;
|
|
export type UpdatePeopleMutationResult = Apollo.MutationResult<UpdatePeopleMutation>;
|
|
export type UpdatePeopleMutationOptions = Apollo.BaseMutationOptions<UpdatePeopleMutation, UpdatePeopleMutationVariables>;
|
|
export const InsertPersonDocument = gql`
|
|
mutation InsertPerson($id: String!, $firstname: String!, $lastname: String!, $phone: String!, $city: String!, $email: String!, $createdAt: DateTime) {
|
|
createOnePerson(
|
|
data: {id: $id, firstname: $firstname, lastname: $lastname, phone: $phone, city: $city, email: $email, createdAt: $createdAt}
|
|
) {
|
|
city
|
|
company {
|
|
domainName
|
|
name
|
|
id
|
|
}
|
|
email
|
|
firstname
|
|
id
|
|
lastname
|
|
phone
|
|
createdAt
|
|
}
|
|
}
|
|
`;
|
|
export type InsertPersonMutationFn = Apollo.MutationFunction<InsertPersonMutation, InsertPersonMutationVariables>;
|
|
|
|
/**
|
|
* __useInsertPersonMutation__
|
|
*
|
|
* To run a mutation, you first call `useInsertPersonMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useInsertPersonMutation` 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 [insertPersonMutation, { data, loading, error }] = useInsertPersonMutation({
|
|
* variables: {
|
|
* id: // value for 'id'
|
|
* firstname: // value for 'firstname'
|
|
* lastname: // value for 'lastname'
|
|
* phone: // value for 'phone'
|
|
* city: // value for 'city'
|
|
* email: // value for 'email'
|
|
* createdAt: // value for 'createdAt'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useInsertPersonMutation(baseOptions?: Apollo.MutationHookOptions<InsertPersonMutation, InsertPersonMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<InsertPersonMutation, InsertPersonMutationVariables>(InsertPersonDocument, options);
|
|
}
|
|
export type InsertPersonMutationHookResult = ReturnType<typeof useInsertPersonMutation>;
|
|
export type InsertPersonMutationResult = Apollo.MutationResult<InsertPersonMutation>;
|
|
export type InsertPersonMutationOptions = Apollo.BaseMutationOptions<InsertPersonMutation, InsertPersonMutationVariables>;
|
|
export const DeletePeopleDocument = gql`
|
|
mutation DeletePeople($ids: [String!]) {
|
|
deleteManyPerson(where: {id: {in: $ids}}) {
|
|
count
|
|
}
|
|
}
|
|
`;
|
|
export type DeletePeopleMutationFn = Apollo.MutationFunction<DeletePeopleMutation, DeletePeopleMutationVariables>;
|
|
|
|
/**
|
|
* __useDeletePeopleMutation__
|
|
*
|
|
* To run a mutation, you first call `useDeletePeopleMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useDeletePeopleMutation` 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 [deletePeopleMutation, { data, loading, error }] = useDeletePeopleMutation({
|
|
* variables: {
|
|
* ids: // value for 'ids'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useDeletePeopleMutation(baseOptions?: Apollo.MutationHookOptions<DeletePeopleMutation, DeletePeopleMutationVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useMutation<DeletePeopleMutation, DeletePeopleMutationVariables>(DeletePeopleDocument, options);
|
|
}
|
|
export type DeletePeopleMutationHookResult = ReturnType<typeof useDeletePeopleMutation>;
|
|
export type DeletePeopleMutationResult = Apollo.MutationResult<DeletePeopleMutation>;
|
|
export type DeletePeopleMutationOptions = Apollo.BaseMutationOptions<DeletePeopleMutation, DeletePeopleMutationVariables>;
|
|
export const SearchPeopleQueryDocument = gql`
|
|
query SearchPeopleQuery($where: PersonWhereInput, $limit: Int) {
|
|
searchResults: findManyPerson(where: $where, take: $limit) {
|
|
id
|
|
phone
|
|
email
|
|
city
|
|
firstname
|
|
lastname
|
|
createdAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSearchPeopleQueryQuery__
|
|
*
|
|
* To run a query within a React component, call `useSearchPeopleQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useSearchPeopleQueryQuery` 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 } = useSearchPeopleQueryQuery({
|
|
* variables: {
|
|
* where: // value for 'where'
|
|
* limit: // value for 'limit'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSearchPeopleQueryQuery(baseOptions?: Apollo.QueryHookOptions<SearchPeopleQueryQuery, SearchPeopleQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<SearchPeopleQueryQuery, SearchPeopleQueryQueryVariables>(SearchPeopleQueryDocument, options);
|
|
}
|
|
export function useSearchPeopleQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchPeopleQueryQuery, SearchPeopleQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<SearchPeopleQueryQuery, SearchPeopleQueryQueryVariables>(SearchPeopleQueryDocument, options);
|
|
}
|
|
export type SearchPeopleQueryQueryHookResult = ReturnType<typeof useSearchPeopleQueryQuery>;
|
|
export type SearchPeopleQueryLazyQueryHookResult = ReturnType<typeof useSearchPeopleQueryLazyQuery>;
|
|
export type SearchPeopleQueryQueryResult = Apollo.QueryResult<SearchPeopleQueryQuery, SearchPeopleQueryQueryVariables>;
|
|
export const SearchUserQueryDocument = gql`
|
|
query SearchUserQuery($where: UserWhereInput, $limit: Int) {
|
|
searchResults: findManyUser(where: $where, take: $limit) {
|
|
id
|
|
email
|
|
displayName
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSearchUserQueryQuery__
|
|
*
|
|
* To run a query within a React component, call `useSearchUserQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useSearchUserQueryQuery` 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 } = useSearchUserQueryQuery({
|
|
* variables: {
|
|
* where: // value for 'where'
|
|
* limit: // value for 'limit'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSearchUserQueryQuery(baseOptions?: Apollo.QueryHookOptions<SearchUserQueryQuery, SearchUserQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<SearchUserQueryQuery, SearchUserQueryQueryVariables>(SearchUserQueryDocument, options);
|
|
}
|
|
export function useSearchUserQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchUserQueryQuery, SearchUserQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<SearchUserQueryQuery, SearchUserQueryQueryVariables>(SearchUserQueryDocument, options);
|
|
}
|
|
export type SearchUserQueryQueryHookResult = ReturnType<typeof useSearchUserQueryQuery>;
|
|
export type SearchUserQueryLazyQueryHookResult = ReturnType<typeof useSearchUserQueryLazyQuery>;
|
|
export type SearchUserQueryQueryResult = Apollo.QueryResult<SearchUserQueryQuery, SearchUserQueryQueryVariables>;
|
|
export const EmptyQueryDocument = gql`
|
|
query EmptyQuery {
|
|
searchResults: findManyUser {
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useEmptyQueryQuery__
|
|
*
|
|
* To run a query within a React component, call `useEmptyQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useEmptyQueryQuery` 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 } = useEmptyQueryQuery({
|
|
* variables: {
|
|
* },
|
|
* });
|
|
*/
|
|
export function useEmptyQueryQuery(baseOptions?: Apollo.QueryHookOptions<EmptyQueryQuery, EmptyQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<EmptyQueryQuery, EmptyQueryQueryVariables>(EmptyQueryDocument, options);
|
|
}
|
|
export function useEmptyQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EmptyQueryQuery, EmptyQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<EmptyQueryQuery, EmptyQueryQueryVariables>(EmptyQueryDocument, options);
|
|
}
|
|
export type EmptyQueryQueryHookResult = ReturnType<typeof useEmptyQueryQuery>;
|
|
export type EmptyQueryLazyQueryHookResult = ReturnType<typeof useEmptyQueryLazyQuery>;
|
|
export type EmptyQueryQueryResult = Apollo.QueryResult<EmptyQueryQuery, EmptyQueryQueryVariables>;
|
|
export const SearchCompanyQueryDocument = gql`
|
|
query SearchCompanyQuery($where: CompanyWhereInput, $limit: Int) {
|
|
searchResults: findManyCompany(where: $where, take: $limit) {
|
|
id
|
|
name
|
|
domainName
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useSearchCompanyQueryQuery__
|
|
*
|
|
* To run a query within a React component, call `useSearchCompanyQueryQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useSearchCompanyQueryQuery` 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 } = useSearchCompanyQueryQuery({
|
|
* variables: {
|
|
* where: // value for 'where'
|
|
* limit: // value for 'limit'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSearchCompanyQueryQuery(baseOptions?: Apollo.QueryHookOptions<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>(SearchCompanyQueryDocument, options);
|
|
}
|
|
export function useSearchCompanyQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>(SearchCompanyQueryDocument, options);
|
|
}
|
|
export type SearchCompanyQueryQueryHookResult = ReturnType<typeof useSearchCompanyQueryQuery>;
|
|
export type SearchCompanyQueryLazyQueryHookResult = ReturnType<typeof useSearchCompanyQueryLazyQuery>;
|
|
export type SearchCompanyQueryQueryResult = Apollo.QueryResult<SearchCompanyQueryQuery, SearchCompanyQueryQueryVariables>;
|
|
export const GetCurrentUserDocument = gql`
|
|
query GetCurrentUser($uuid: String) {
|
|
users: findManyUser(where: {id: {equals: $uuid}}) {
|
|
id
|
|
email
|
|
displayName
|
|
workspaceMember {
|
|
workspace {
|
|
id
|
|
domainName
|
|
displayName
|
|
logo
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetCurrentUserQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetCurrentUserQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetCurrentUserQuery` 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 } = useGetCurrentUserQuery({
|
|
* variables: {
|
|
* uuid: // value for 'uuid'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetCurrentUserQuery(baseOptions?: Apollo.QueryHookOptions<GetCurrentUserQuery, GetCurrentUserQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetCurrentUserQuery, GetCurrentUserQueryVariables>(GetCurrentUserDocument, options);
|
|
}
|
|
export function useGetCurrentUserLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCurrentUserQuery, GetCurrentUserQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetCurrentUserQuery, GetCurrentUserQueryVariables>(GetCurrentUserDocument, options);
|
|
}
|
|
export type GetCurrentUserQueryHookResult = ReturnType<typeof useGetCurrentUserQuery>;
|
|
export type GetCurrentUserLazyQueryHookResult = ReturnType<typeof useGetCurrentUserLazyQuery>;
|
|
export type GetCurrentUserQueryResult = Apollo.QueryResult<GetCurrentUserQuery, GetCurrentUserQueryVariables>;
|
|
export const GetUsersDocument = gql`
|
|
query getUsers {
|
|
findManyUser {
|
|
id
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetUsersQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetUsersQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUsersQuery` 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 } = useGetUsersQuery({
|
|
* variables: {
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUsersQuery(baseOptions?: Apollo.QueryHookOptions<GetUsersQuery, GetUsersQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useQuery<GetUsersQuery, GetUsersQueryVariables>(GetUsersDocument, options);
|
|
}
|
|
export function useGetUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUsersQuery, GetUsersQueryVariables>) {
|
|
const options = {...defaultOptions, ...baseOptions}
|
|
return Apollo.useLazyQuery<GetUsersQuery, GetUsersQueryVariables>(GetUsersDocument, options);
|
|
}
|
|
export type GetUsersQueryHookResult = ReturnType<typeof useGetUsersQuery>;
|
|
export type GetUsersLazyQueryHookResult = ReturnType<typeof useGetUsersLazyQuery>;
|
|
export type GetUsersQueryResult = Apollo.QueryResult<GetUsersQuery, GetUsersQueryVariables>; |