Kristaps Fabians Geikins
1979 lines
66 KiB
TypeScript
1979 lines
66 KiB
TypeScript
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]> };
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: string;
|
|
String: string;
|
|
Boolean: boolean;
|
|
Int: number;
|
|
Float: number;
|
|
/** The `BigInt` scalar type represents non-fractional signed whole numeric values. */
|
|
BigInt: bigint;
|
|
/** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
|
|
DateTime: string;
|
|
EmailAddress: any;
|
|
/** The `JSONObject` scalar type represents JSON objects as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
|
|
JSONObject: Record<string, unknown>;
|
|
};
|
|
|
|
export type Activity = {
|
|
__typename?: 'Activity';
|
|
actionType: Scalars['String'];
|
|
id: Scalars['ID'];
|
|
info: Scalars['JSONObject'];
|
|
message: Scalars['String'];
|
|
resourceId: Scalars['String'];
|
|
resourceType: Scalars['String'];
|
|
streamId?: Maybe<Scalars['String']>;
|
|
time: Scalars['DateTime'];
|
|
userId: Scalars['String'];
|
|
};
|
|
|
|
export type ActivityCollection = {
|
|
__typename?: 'ActivityCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<Maybe<Activity>>>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type AdminUsersListCollection = {
|
|
__typename?: 'AdminUsersListCollection';
|
|
items: Array<AdminUsersListItem>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
/**
|
|
* A representation of a registered or invited user in the admin users list. Either registeredUser
|
|
* or invitedUser will always be set, both values can't be null.
|
|
*/
|
|
export type AdminUsersListItem = {
|
|
__typename?: 'AdminUsersListItem';
|
|
id: Scalars['String'];
|
|
invitedUser?: Maybe<ServerInvite>;
|
|
registeredUser?: Maybe<User>;
|
|
};
|
|
|
|
export type ApiToken = {
|
|
__typename?: 'ApiToken';
|
|
createdAt: Scalars['DateTime'];
|
|
id: Scalars['String'];
|
|
lastChars: Scalars['String'];
|
|
lastUsed: Scalars['DateTime'];
|
|
lifespan: Scalars['BigInt'];
|
|
name: Scalars['String'];
|
|
scopes: Array<Maybe<Scalars['String']>>;
|
|
};
|
|
|
|
export type ApiTokenCreateInput = {
|
|
lifespan?: InputMaybe<Scalars['BigInt']>;
|
|
name: Scalars['String'];
|
|
scopes: Array<Scalars['String']>;
|
|
};
|
|
|
|
export type AppAuthor = {
|
|
__typename?: 'AppAuthor';
|
|
avatar?: Maybe<Scalars['String']>;
|
|
id?: Maybe<Scalars['String']>;
|
|
name?: Maybe<Scalars['String']>;
|
|
};
|
|
|
|
export type AppCreateInput = {
|
|
description: Scalars['String'];
|
|
logo?: InputMaybe<Scalars['String']>;
|
|
name: Scalars['String'];
|
|
public?: InputMaybe<Scalars['Boolean']>;
|
|
redirectUrl: Scalars['String'];
|
|
scopes: Array<InputMaybe<Scalars['String']>>;
|
|
termsAndConditionsLink?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type AppUpdateInput = {
|
|
description: Scalars['String'];
|
|
id: Scalars['String'];
|
|
logo?: InputMaybe<Scalars['String']>;
|
|
name: Scalars['String'];
|
|
public?: InputMaybe<Scalars['Boolean']>;
|
|
redirectUrl: Scalars['String'];
|
|
scopes: Array<InputMaybe<Scalars['String']>>;
|
|
termsAndConditionsLink?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type AuthStrategy = {
|
|
__typename?: 'AuthStrategy';
|
|
color?: Maybe<Scalars['String']>;
|
|
icon: Scalars['String'];
|
|
id: Scalars['String'];
|
|
name: Scalars['String'];
|
|
url: Scalars['String'];
|
|
};
|
|
|
|
export type BlobMetadata = {
|
|
__typename?: 'BlobMetadata';
|
|
createdAt: Scalars['DateTime'];
|
|
fileHash?: Maybe<Scalars['String']>;
|
|
fileName: Scalars['String'];
|
|
fileSize?: Maybe<Scalars['Int']>;
|
|
fileType: Scalars['String'];
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
uploadError?: Maybe<Scalars['String']>;
|
|
uploadStatus: Scalars['Int'];
|
|
userId: Scalars['String'];
|
|
};
|
|
|
|
export type BlobMetadataCollection = {
|
|
__typename?: 'BlobMetadataCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<BlobMetadata>>;
|
|
totalCount: Scalars['Int'];
|
|
totalSize: Scalars['Int'];
|
|
};
|
|
|
|
export type Branch = {
|
|
__typename?: 'Branch';
|
|
/** All the recent activity on this branch in chronological order */
|
|
activity?: Maybe<ActivityCollection>;
|
|
author?: Maybe<User>;
|
|
commits?: Maybe<CommitCollection>;
|
|
createdAt?: Maybe<Scalars['DateTime']>;
|
|
description?: Maybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
name: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type BranchActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']>;
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
export type BranchCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
export type BranchCollection = {
|
|
__typename?: 'BranchCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<Branch>>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type BranchCreateInput = {
|
|
description?: InputMaybe<Scalars['String']>;
|
|
name: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type BranchDeleteInput = {
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type BranchUpdateInput = {
|
|
description?: InputMaybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
name?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type Comment = {
|
|
__typename?: 'Comment';
|
|
archived: Scalars['Boolean'];
|
|
authorId: Scalars['String'];
|
|
createdAt?: Maybe<Scalars['DateTime']>;
|
|
data?: Maybe<Scalars['JSONObject']>;
|
|
id: Scalars['String'];
|
|
/** Plain-text version of the comment text, ideal for previews */
|
|
rawText: Scalars['String'];
|
|
reactions?: Maybe<Array<Maybe<Scalars['String']>>>;
|
|
/** Gets the replies to this comment. */
|
|
replies?: Maybe<CommentCollection>;
|
|
/** Resources that this comment targets. Can be a mixture of either one stream, or multiple commits and objects. */
|
|
resources: Array<ResourceIdentifier>;
|
|
screenshot?: Maybe<Scalars['String']>;
|
|
text: SmartTextEditorValue;
|
|
/** The time this comment was last updated. Corresponds also to the latest reply to this comment, if any. */
|
|
updatedAt?: Maybe<Scalars['DateTime']>;
|
|
/** The last time you viewed this comment. Present only if an auth'ed request. Relevant only if a top level commit. */
|
|
viewedAt?: Maybe<Scalars['DateTime']>;
|
|
};
|
|
|
|
|
|
export type CommentRepliesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
};
|
|
|
|
export type CommentActivityMessage = {
|
|
__typename?: 'CommentActivityMessage';
|
|
comment: Comment;
|
|
type: Scalars['String'];
|
|
};
|
|
|
|
export type CommentCollection = {
|
|
__typename?: 'CommentCollection';
|
|
cursor?: Maybe<Scalars['DateTime']>;
|
|
items: Array<Comment>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type CommentCreateInput = {
|
|
/** IDs of uploaded blobs that should be attached to this comment */
|
|
blobIds: Array<Scalars['String']>;
|
|
data: Scalars['JSONObject'];
|
|
/**
|
|
* Specifies the resources this comment is linked to. There are several use cases:
|
|
* - a comment targets only one resource (commit or object)
|
|
* - a comment targets one or more resources (commits or objects)
|
|
* - a comment targets only a stream
|
|
*/
|
|
resources: Array<InputMaybe<ResourceIdentifierInput>>;
|
|
screenshot?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']>;
|
|
};
|
|
|
|
export type CommentEditInput = {
|
|
/** IDs of uploaded blobs that should be attached to this comment */
|
|
blobIds: Array<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']>;
|
|
};
|
|
|
|
export type CommentThreadActivityMessage = {
|
|
__typename?: 'CommentThreadActivityMessage';
|
|
data?: Maybe<Scalars['JSONObject']>;
|
|
reply?: Maybe<Comment>;
|
|
type: Scalars['String'];
|
|
};
|
|
|
|
export type Commit = {
|
|
__typename?: 'Commit';
|
|
/** All the recent activity on this commit in chronological order */
|
|
activity?: Maybe<ActivityCollection>;
|
|
authorAvatar?: Maybe<Scalars['String']>;
|
|
authorId?: Maybe<Scalars['String']>;
|
|
authorName?: Maybe<Scalars['String']>;
|
|
branchName?: Maybe<Scalars['String']>;
|
|
/**
|
|
* The total number of comments for this commit. To actually get the comments, use the comments query and pass in a resource array consisting of of this commit's id.
|
|
* E.g.,
|
|
* ```
|
|
* query{
|
|
* comments(streamId:"streamId" resources:[{resourceType: commit, resourceId:"commitId"}] ){
|
|
* ...
|
|
* }
|
|
* ```
|
|
*/
|
|
commentCount: Scalars['Int'];
|
|
createdAt?: Maybe<Scalars['DateTime']>;
|
|
id: Scalars['String'];
|
|
message?: Maybe<Scalars['String']>;
|
|
parents?: Maybe<Array<Maybe<Scalars['String']>>>;
|
|
referencedObject: Scalars['String'];
|
|
sourceApplication?: Maybe<Scalars['String']>;
|
|
/**
|
|
* Will throw an authorization error if active user isn't authorized to see it, for example,
|
|
* if a stream isn't public and the user doesn't have the appropriate rights.
|
|
*/
|
|
stream: Stream;
|
|
/** @deprecated Use the stream field instead */
|
|
streamId?: Maybe<Scalars['String']>;
|
|
/** @deprecated Use the stream field instead */
|
|
streamName?: Maybe<Scalars['String']>;
|
|
totalChildrenCount?: Maybe<Scalars['Int']>;
|
|
};
|
|
|
|
|
|
export type CommitActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']>;
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
export type CommitCollection = {
|
|
__typename?: 'CommitCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<Commit>>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type CommitCreateInput = {
|
|
branchName: Scalars['String'];
|
|
message?: InputMaybe<Scalars['String']>;
|
|
objectId: Scalars['String'];
|
|
parents?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
|
|
/**
|
|
* **DEPRECATED** Use the `parents` field.
|
|
* @deprecated Field no longer supported
|
|
*/
|
|
previousCommitIds?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
|
|
sourceApplication?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
totalChildrenCount?: InputMaybe<Scalars['Int']>;
|
|
};
|
|
|
|
export type CommitDeleteInput = {
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type CommitReceivedInput = {
|
|
commitId: Scalars['String'];
|
|
message?: InputMaybe<Scalars['String']>;
|
|
sourceApplication: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type CommitUpdateInput = {
|
|
id: Scalars['String'];
|
|
message?: InputMaybe<Scalars['String']>;
|
|
/** To move the commit to a different branch, please the name of the branch. */
|
|
newBranchName?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type CommitsDeleteInput = {
|
|
commitIds: Array<Scalars['String']>;
|
|
};
|
|
|
|
export type CommitsMoveInput = {
|
|
commitIds: Array<Scalars['String']>;
|
|
targetBranch: Scalars['String'];
|
|
};
|
|
|
|
export enum DiscoverableStreamsSortType {
|
|
CreatedDate = 'CREATED_DATE',
|
|
FavoritesCount = 'FAVORITES_COUNT'
|
|
}
|
|
|
|
export type DiscoverableStreamsSortingInput = {
|
|
direction: SortDirection;
|
|
type: DiscoverableStreamsSortType;
|
|
};
|
|
|
|
export type FileUpload = {
|
|
__typename?: 'FileUpload';
|
|
branchName?: Maybe<Scalars['String']>;
|
|
/** If present, the conversion result is stored in this commit. */
|
|
convertedCommitId?: Maybe<Scalars['String']>;
|
|
convertedLastUpdate: Scalars['DateTime'];
|
|
/** Holds any errors or info. */
|
|
convertedMessage?: Maybe<Scalars['String']>;
|
|
/** 0 = queued, 1 = processing, 2 = success, 3 = error */
|
|
convertedStatus: Scalars['Int'];
|
|
fileName: Scalars['String'];
|
|
fileSize: Scalars['Int'];
|
|
fileType: Scalars['String'];
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
uploadComplete: Scalars['Boolean'];
|
|
uploadDate: Scalars['DateTime'];
|
|
/** The user's id that uploaded this file. */
|
|
userId: Scalars['String'];
|
|
};
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUser = {
|
|
__typename?: 'LimitedUser';
|
|
/** All the recent activity from this user in chronological order */
|
|
activity?: Maybe<ActivityCollection>;
|
|
avatar?: Maybe<Scalars['String']>;
|
|
bio?: Maybe<Scalars['String']>;
|
|
/** Get public stream commits authored by the user */
|
|
commits?: Maybe<CommitCollection>;
|
|
company?: Maybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
name?: Maybe<Scalars['String']>;
|
|
role?: Maybe<Scalars['String']>;
|
|
/** Returns all discoverable streams that the user is a collaborator on */
|
|
streams: StreamCollection;
|
|
/** The user's timeline in chronological order */
|
|
timeline?: Maybe<ActivityCollection>;
|
|
/** Total amount of favorites attached to streams owned by the user */
|
|
totalOwnedStreamsFavorites: Scalars['Int'];
|
|
verified?: Maybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']>;
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserTimelineArgs = {
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: 'Mutation';
|
|
/** The void stares back. */
|
|
_?: Maybe<Scalars['String']>;
|
|
adminDeleteUser: Scalars['Boolean'];
|
|
/** Creates an personal api token. */
|
|
apiTokenCreate: Scalars['String'];
|
|
/** Revokes (deletes) an personal api token. */
|
|
apiTokenRevoke: Scalars['Boolean'];
|
|
/** Register a new third party application. */
|
|
appCreate: Scalars['String'];
|
|
/** Deletes a thirty party application. */
|
|
appDelete: Scalars['Boolean'];
|
|
/** Revokes (de-authorizes) an application that you have previously authorized. */
|
|
appRevokeAccess?: Maybe<Scalars['Boolean']>;
|
|
/** Update an existing third party application. **Note: This will invalidate all existing tokens, refresh tokens and access codes and will require existing users to re-authorize it.** */
|
|
appUpdate: Scalars['Boolean'];
|
|
branchCreate: Scalars['String'];
|
|
branchDelete: Scalars['Boolean'];
|
|
branchUpdate: Scalars['Boolean'];
|
|
/** Archives a comment. */
|
|
commentArchive: Scalars['Boolean'];
|
|
/** Creates a comment */
|
|
commentCreate: Scalars['String'];
|
|
/** Edits a comment. */
|
|
commentEdit: Scalars['Boolean'];
|
|
/** Adds a reply to a comment. */
|
|
commentReply: Scalars['String'];
|
|
/** Flags a comment as viewed by you (the logged in user). */
|
|
commentView: Scalars['Boolean'];
|
|
commitCreate: Scalars['String'];
|
|
commitDelete: Scalars['Boolean'];
|
|
commitReceive: Scalars['Boolean'];
|
|
commitUpdate: Scalars['Boolean'];
|
|
/** Delete a batch of commits */
|
|
commitsDelete: Scalars['Boolean'];
|
|
/** Move a batch of commits to a new branch */
|
|
commitsMove: Scalars['Boolean'];
|
|
/** Delete a pending invite */
|
|
inviteDelete: Scalars['Boolean'];
|
|
/** Re-send a pending invite */
|
|
inviteResend: Scalars['Boolean'];
|
|
objectCreate: Array<Maybe<Scalars['String']>>;
|
|
/** (Re-)send the account verification e-mail */
|
|
requestVerification: Scalars['Boolean'];
|
|
serverInfoUpdate?: Maybe<Scalars['Boolean']>;
|
|
serverInviteBatchCreate: Scalars['Boolean'];
|
|
/** Invite a new user to the speckle server and return the invite ID */
|
|
serverInviteCreate: Scalars['Boolean'];
|
|
/** Request access to a specific stream */
|
|
streamAccessRequestCreate: StreamAccessRequest;
|
|
/** Accept or decline a stream access request. Must be a stream owner to invoke this. */
|
|
streamAccessRequestUse: Scalars['Boolean'];
|
|
/** Creates a new stream. */
|
|
streamCreate?: Maybe<Scalars['String']>;
|
|
/** Deletes an existing stream. */
|
|
streamDelete: Scalars['Boolean'];
|
|
streamFavorite?: Maybe<Stream>;
|
|
streamInviteBatchCreate: Scalars['Boolean'];
|
|
/** Cancel a pending stream invite. Can only be invoked by a stream owner. */
|
|
streamInviteCancel: Scalars['Boolean'];
|
|
/** Invite a new or registered user to the specified stream */
|
|
streamInviteCreate: Scalars['Boolean'];
|
|
/** Accept or decline a stream invite */
|
|
streamInviteUse: Scalars['Boolean'];
|
|
/** Remove yourself from stream collaborators (not possible for the owner) */
|
|
streamLeave: Scalars['Boolean'];
|
|
/** Revokes the permissions of a user on a given stream. */
|
|
streamRevokePermission?: Maybe<Scalars['Boolean']>;
|
|
/** Updates an existing stream. */
|
|
streamUpdate: Scalars['Boolean'];
|
|
/** Update permissions of a user on a given stream. */
|
|
streamUpdatePermission?: Maybe<Scalars['Boolean']>;
|
|
streamsDelete: Scalars['Boolean'];
|
|
/** Used for broadcasting real time typing status in comment threads. Does not persist any info. */
|
|
userCommentThreadActivityBroadcast: Scalars['Boolean'];
|
|
/** Delete a user's account. */
|
|
userDelete: Scalars['Boolean'];
|
|
userNotificationPreferencesUpdate?: Maybe<Scalars['Boolean']>;
|
|
userRoleChange: Scalars['Boolean'];
|
|
/** Edits a user's profile. */
|
|
userUpdate: Scalars['Boolean'];
|
|
/** Used for broadcasting real time chat head bubbles and status. Does not persist any info. */
|
|
userViewerActivityBroadcast: Scalars['Boolean'];
|
|
/** Creates a new webhook on a stream */
|
|
webhookCreate: Scalars['String'];
|
|
/** Deletes an existing webhook */
|
|
webhookDelete: Scalars['String'];
|
|
/** Updates an existing webhook */
|
|
webhookUpdate: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationAdminDeleteUserArgs = {
|
|
userConfirmation: UserDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationApiTokenCreateArgs = {
|
|
token: ApiTokenCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationApiTokenRevokeArgs = {
|
|
token: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationAppCreateArgs = {
|
|
app: AppCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationAppDeleteArgs = {
|
|
appId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationAppRevokeAccessArgs = {
|
|
appId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationAppUpdateArgs = {
|
|
app: AppUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchCreateArgs = {
|
|
branch: BranchCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchDeleteArgs = {
|
|
branch: BranchDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchUpdateArgs = {
|
|
branch: BranchUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentArchiveArgs = {
|
|
archived?: Scalars['Boolean'];
|
|
commentId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationCommentCreateArgs = {
|
|
input: CommentCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentEditArgs = {
|
|
input: CommentEditInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentReplyArgs = {
|
|
input: ReplyCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentViewArgs = {
|
|
commentId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationCommitCreateArgs = {
|
|
commit: CommitCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommitDeleteArgs = {
|
|
commit: CommitDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationCommitReceiveArgs = {
|
|
input: CommitReceivedInput;
|
|
};
|
|
|
|
|
|
export type MutationCommitUpdateArgs = {
|
|
commit: CommitUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommitsDeleteArgs = {
|
|
input: CommitsDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationCommitsMoveArgs = {
|
|
input: CommitsMoveInput;
|
|
};
|
|
|
|
|
|
export type MutationInviteDeleteArgs = {
|
|
inviteId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationInviteResendArgs = {
|
|
inviteId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationObjectCreateArgs = {
|
|
objectInput: ObjectCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationServerInfoUpdateArgs = {
|
|
info: ServerInfoUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationServerInviteBatchCreateArgs = {
|
|
input: Array<ServerInviteCreateInput>;
|
|
};
|
|
|
|
|
|
export type MutationServerInviteCreateArgs = {
|
|
input: ServerInviteCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamAccessRequestCreateArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamAccessRequestUseArgs = {
|
|
accept: Scalars['Boolean'];
|
|
requestId: Scalars['String'];
|
|
role?: StreamRole;
|
|
};
|
|
|
|
|
|
export type MutationStreamCreateArgs = {
|
|
stream: StreamCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamDeleteArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamFavoriteArgs = {
|
|
favorited: Scalars['Boolean'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteBatchCreateArgs = {
|
|
input: Array<StreamInviteCreateInput>;
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteCancelArgs = {
|
|
inviteId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteCreateArgs = {
|
|
input: StreamInviteCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteUseArgs = {
|
|
accept: Scalars['Boolean'];
|
|
streamId: Scalars['String'];
|
|
token: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamLeaveArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationStreamRevokePermissionArgs = {
|
|
permissionParams: StreamRevokePermissionInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamUpdateArgs = {
|
|
stream: StreamUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamUpdatePermissionArgs = {
|
|
permissionParams: StreamUpdatePermissionInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamsDeleteArgs = {
|
|
ids?: InputMaybe<Array<Scalars['String']>>;
|
|
};
|
|
|
|
|
|
export type MutationUserCommentThreadActivityBroadcastArgs = {
|
|
commentId: Scalars['String'];
|
|
data?: InputMaybe<Scalars['JSONObject']>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationUserDeleteArgs = {
|
|
userConfirmation: UserDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationUserNotificationPreferencesUpdateArgs = {
|
|
preferences: Scalars['JSONObject'];
|
|
};
|
|
|
|
|
|
export type MutationUserRoleChangeArgs = {
|
|
userRoleInput: UserRoleInput;
|
|
};
|
|
|
|
|
|
export type MutationUserUpdateArgs = {
|
|
user: UserUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationUserViewerActivityBroadcastArgs = {
|
|
data?: InputMaybe<Scalars['JSONObject']>;
|
|
resourceId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type MutationWebhookCreateArgs = {
|
|
webhook: WebhookCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationWebhookDeleteArgs = {
|
|
webhook: WebhookDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationWebhookUpdateArgs = {
|
|
webhook: WebhookUpdateInput;
|
|
};
|
|
|
|
export type Object = {
|
|
__typename?: 'Object';
|
|
applicationId?: Maybe<Scalars['String']>;
|
|
/**
|
|
* Get any objects that this object references. In the case of commits, this will give you a commit's constituent objects.
|
|
* **NOTE**: Providing any of the two last arguments ( `query`, `orderBy` ) will trigger a different code branch that executes a much more expensive SQL query. It is not recommended to do so for basic clients that are interested in purely getting all the objects of a given commit.
|
|
*/
|
|
children: ObjectCollection;
|
|
/**
|
|
* The total number of comments for this commit. To actually get the comments, use the comments query and pass in a resource array consisting of of this object's id.
|
|
* E.g.,
|
|
* ```
|
|
* query{
|
|
* comments(streamId:"streamId" resources:[{resourceType: object, resourceId:"objectId"}] ){
|
|
* ...
|
|
* }
|
|
* ```
|
|
*/
|
|
commentCount: Scalars['Int'];
|
|
createdAt?: Maybe<Scalars['DateTime']>;
|
|
/** The full object, with all its props & other things. **NOTE:** If you're requesting objects for the purpose of recreating & displaying, you probably only want to request this specific field. */
|
|
data?: Maybe<Scalars['JSONObject']>;
|
|
id: Scalars['String'];
|
|
speckleType?: Maybe<Scalars['String']>;
|
|
totalChildrenCount?: Maybe<Scalars['Int']>;
|
|
};
|
|
|
|
|
|
export type ObjectChildrenArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
depth?: Scalars['Int'];
|
|
limit?: Scalars['Int'];
|
|
orderBy?: InputMaybe<Scalars['JSONObject']>;
|
|
query?: InputMaybe<Array<Scalars['JSONObject']>>;
|
|
select?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
|
|
};
|
|
|
|
export type ObjectCollection = {
|
|
__typename?: 'ObjectCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
objects: Array<Maybe<Object>>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type ObjectCreateInput = {
|
|
/** The objects you want to create. */
|
|
objects: Array<InputMaybe<Scalars['JSONObject']>>;
|
|
/** The stream against which these objects will be created. */
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type PasswordStrengthCheckFeedback = {
|
|
__typename?: 'PasswordStrengthCheckFeedback';
|
|
suggestions: Array<Scalars['String']>;
|
|
warning?: Maybe<Scalars['String']>;
|
|
};
|
|
|
|
export type PasswordStrengthCheckResults = {
|
|
__typename?: 'PasswordStrengthCheckResults';
|
|
/** Verbal feedback to help choose better passwords. set when score <= 2. */
|
|
feedback: PasswordStrengthCheckFeedback;
|
|
/**
|
|
* Integer from 0-4 (useful for implementing a strength bar):
|
|
* 0 too guessable: risky password. (guesses < 10^3)
|
|
* 1 very guessable: protection from throttled online attacks. (guesses < 10^6)
|
|
* 2 somewhat guessable: protection from unthrottled online attacks. (guesses < 10^8)
|
|
* 3 safely unguessable: moderate protection from offline slow-hash scenario. (guesses < 10^10)
|
|
* 4 very unguessable: strong protection from offline slow-hash scenario. (guesses >= 10^10)
|
|
*/
|
|
score: Scalars['Int'];
|
|
};
|
|
|
|
export type PendingStreamCollaborator = {
|
|
__typename?: 'PendingStreamCollaborator';
|
|
id: Scalars['String'];
|
|
inviteId: Scalars['String'];
|
|
invitedBy: LimitedUser;
|
|
role: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
streamName: Scalars['String'];
|
|
/** E-mail address or name of the invited user */
|
|
title: Scalars['String'];
|
|
/** Only available if the active user is the pending stream collaborator */
|
|
token?: Maybe<Scalars['String']>;
|
|
/** Set only if user is registered */
|
|
user?: Maybe<LimitedUser>;
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: 'Query';
|
|
/** Stare into the void. */
|
|
_?: Maybe<Scalars['String']>;
|
|
/** Gets the profile of the authenticated user or null if not authenticated */
|
|
activeUser?: Maybe<User>;
|
|
/** All the streams of the server. Available to admins only. */
|
|
adminStreams?: Maybe<StreamCollection>;
|
|
/**
|
|
* Get all (or search for specific) users, registered or invited, from the server in a paginated view.
|
|
* The query looks for matches in name, company and email.
|
|
*/
|
|
adminUsers?: Maybe<AdminUsersListCollection>;
|
|
/** Gets a specific app from the server. */
|
|
app?: Maybe<ServerApp>;
|
|
/** Returns all the publicly available apps on this server. */
|
|
apps?: Maybe<Array<Maybe<ServerAppListItem>>>;
|
|
comment?: Maybe<Comment>;
|
|
/**
|
|
* This query can be used in the following ways:
|
|
* - get all the comments for a stream: **do not pass in any resource identifiers**.
|
|
* - get the comments targeting any of a set of provided resources (comments/objects): **pass in an array of resources.**
|
|
*/
|
|
comments?: Maybe<CommentCollection>;
|
|
/** All of the discoverable streams of the server */
|
|
discoverableStreams?: Maybe<StreamCollection>;
|
|
/** Get the (limited) profile information of another server user */
|
|
otherUser?: Maybe<LimitedUser>;
|
|
serverInfo: ServerInfo;
|
|
serverStats: ServerStats;
|
|
/**
|
|
* Returns a specific stream. Will throw an authorization error if active user isn't authorized
|
|
* to see it, for example, if a stream isn't public and the user doesn't have the appropriate rights.
|
|
*/
|
|
stream?: Maybe<Stream>;
|
|
/** Get authed user's stream access request */
|
|
streamAccessRequest?: Maybe<StreamAccessRequest>;
|
|
/**
|
|
* Look for an invitation to a stream, for the current user (authed or not). If token
|
|
* isn't specified, the server will look for any valid invite.
|
|
*/
|
|
streamInvite?: Maybe<PendingStreamCollaborator>;
|
|
/** Get all invitations to streams that the active user has */
|
|
streamInvites: Array<PendingStreamCollaborator>;
|
|
/**
|
|
* Returns all streams that the active user is a collaborator on.
|
|
* Pass in the `query` parameter to search by name, description or ID.
|
|
*/
|
|
streams?: Maybe<StreamCollection>;
|
|
/**
|
|
* Gets the profile of a user. If no id argument is provided, will return the current authenticated user's profile (as extracted from the authorization header).
|
|
* @deprecated To be removed in the near future! Use 'activeUser' to get info about the active user or 'otherUser' to get info about another user.
|
|
*/
|
|
user?: Maybe<User>;
|
|
/** Validate password strength */
|
|
userPwdStrength: PasswordStrengthCheckResults;
|
|
/**
|
|
* Search for users and return limited metadata about them, if you have the server:user role.
|
|
* The query looks for matches in name & email
|
|
*/
|
|
userSearch?: Maybe<UserSearchResultCollection>;
|
|
};
|
|
|
|
|
|
export type QueryAdminStreamsArgs = {
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
offset?: InputMaybe<Scalars['Int']>;
|
|
orderBy?: InputMaybe<Scalars['String']>;
|
|
query?: InputMaybe<Scalars['String']>;
|
|
visibility?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type QueryAdminUsersArgs = {
|
|
limit?: Scalars['Int'];
|
|
offset?: Scalars['Int'];
|
|
query?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type QueryAppArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryCommentArgs = {
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryCommentsArgs = {
|
|
archived?: Scalars['Boolean'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
resources?: InputMaybe<Array<InputMaybe<ResourceIdentifierInput>>>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryDiscoverableStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
sort?: InputMaybe<DiscoverableStreamsSortingInput>;
|
|
};
|
|
|
|
|
|
export type QueryOtherUserArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryStreamArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryStreamAccessRequestArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryStreamInviteArgs = {
|
|
streamId: Scalars['String'];
|
|
token?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type QueryStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
query?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type QueryUserArgs = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type QueryUserPwdStrengthArgs = {
|
|
pwd: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type QueryUserSearchArgs = {
|
|
archived?: InputMaybe<Scalars['Boolean']>;
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
query: Scalars['String'];
|
|
};
|
|
|
|
export type ReplyCreateInput = {
|
|
/** IDs of uploaded blobs that should be attached to this reply */
|
|
blobIds: Array<Scalars['String']>;
|
|
data?: InputMaybe<Scalars['JSONObject']>;
|
|
parentComment: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']>;
|
|
};
|
|
|
|
export type ResourceIdentifier = {
|
|
__typename?: 'ResourceIdentifier';
|
|
resourceId: Scalars['String'];
|
|
resourceType: ResourceType;
|
|
};
|
|
|
|
export type ResourceIdentifierInput = {
|
|
resourceId: Scalars['String'];
|
|
resourceType: ResourceType;
|
|
};
|
|
|
|
export enum ResourceType {
|
|
Comment = 'comment',
|
|
Commit = 'commit',
|
|
Object = 'object',
|
|
Stream = 'stream'
|
|
}
|
|
|
|
/** Available roles. */
|
|
export type Role = {
|
|
__typename?: 'Role';
|
|
description: Scalars['String'];
|
|
name: Scalars['String'];
|
|
resourceTarget: Scalars['String'];
|
|
};
|
|
|
|
/** Available scopes. */
|
|
export type Scope = {
|
|
__typename?: 'Scope';
|
|
description: Scalars['String'];
|
|
name: Scalars['String'];
|
|
};
|
|
|
|
export type ServerApp = {
|
|
__typename?: 'ServerApp';
|
|
author?: Maybe<AppAuthor>;
|
|
createdAt: Scalars['DateTime'];
|
|
description?: Maybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
logo?: Maybe<Scalars['String']>;
|
|
name: Scalars['String'];
|
|
public?: Maybe<Scalars['Boolean']>;
|
|
redirectUrl: Scalars['String'];
|
|
scopes: Array<Maybe<Scope>>;
|
|
secret?: Maybe<Scalars['String']>;
|
|
termsAndConditionsLink?: Maybe<Scalars['String']>;
|
|
trustByDefault?: Maybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
export type ServerAppListItem = {
|
|
__typename?: 'ServerAppListItem';
|
|
author?: Maybe<AppAuthor>;
|
|
description?: Maybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
logo?: Maybe<Scalars['String']>;
|
|
name: Scalars['String'];
|
|
redirectUrl: Scalars['String'];
|
|
termsAndConditionsLink?: Maybe<Scalars['String']>;
|
|
trustByDefault?: Maybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
/** Information about this server. */
|
|
export type ServerInfo = {
|
|
__typename?: 'ServerInfo';
|
|
adminContact?: Maybe<Scalars['String']>;
|
|
/** The authentication strategies available on this server. */
|
|
authStrategies?: Maybe<Array<Maybe<AuthStrategy>>>;
|
|
blobSizeLimitBytes: Scalars['Int'];
|
|
canonicalUrl?: Maybe<Scalars['String']>;
|
|
company?: Maybe<Scalars['String']>;
|
|
description?: Maybe<Scalars['String']>;
|
|
inviteOnly?: Maybe<Scalars['Boolean']>;
|
|
name: Scalars['String'];
|
|
roles: Array<Maybe<Role>>;
|
|
scopes: Array<Maybe<Scope>>;
|
|
termsOfService?: Maybe<Scalars['String']>;
|
|
version?: Maybe<Scalars['String']>;
|
|
};
|
|
|
|
export type ServerInfoUpdateInput = {
|
|
adminContact?: InputMaybe<Scalars['String']>;
|
|
company?: InputMaybe<Scalars['String']>;
|
|
description?: InputMaybe<Scalars['String']>;
|
|
inviteOnly?: InputMaybe<Scalars['Boolean']>;
|
|
name: Scalars['String'];
|
|
termsOfService?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type ServerInvite = {
|
|
__typename?: 'ServerInvite';
|
|
email: Scalars['String'];
|
|
id: Scalars['String'];
|
|
invitedBy: LimitedUser;
|
|
};
|
|
|
|
export type ServerInviteCreateInput = {
|
|
email: Scalars['String'];
|
|
message?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type ServerStats = {
|
|
__typename?: 'ServerStats';
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
commitHistory?: Maybe<Array<Maybe<Scalars['JSONObject']>>>;
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
objectHistory?: Maybe<Array<Maybe<Scalars['JSONObject']>>>;
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
streamHistory?: Maybe<Array<Maybe<Scalars['JSONObject']>>>;
|
|
totalCommitCount: Scalars['Int'];
|
|
totalObjectCount: Scalars['Int'];
|
|
totalStreamCount: Scalars['Int'];
|
|
totalUserCount: Scalars['Int'];
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
userHistory?: Maybe<Array<Maybe<Scalars['JSONObject']>>>;
|
|
};
|
|
|
|
export type SmartTextEditorValue = {
|
|
__typename?: 'SmartTextEditorValue';
|
|
/** File attachments, if any */
|
|
attachments?: Maybe<Array<BlobMetadata>>;
|
|
/**
|
|
* The actual (ProseMirror) document representing the text. Can be empty,
|
|
* if there are attachments.
|
|
*/
|
|
doc?: Maybe<Scalars['JSONObject']>;
|
|
/** The type of editor value (comment, blog post etc.) */
|
|
type: Scalars['String'];
|
|
/** The version of the schema */
|
|
version: Scalars['String'];
|
|
};
|
|
|
|
export enum SortDirection {
|
|
Asc = 'ASC',
|
|
Desc = 'DESC'
|
|
}
|
|
|
|
export type Stream = {
|
|
__typename?: 'Stream';
|
|
/** All the recent activity on this stream in chronological order */
|
|
activity?: Maybe<ActivityCollection>;
|
|
allowPublicComments: Scalars['Boolean'];
|
|
blob?: Maybe<BlobMetadata>;
|
|
/** Get the metadata collection of blobs stored for this stream. */
|
|
blobs?: Maybe<BlobMetadataCollection>;
|
|
branch?: Maybe<Branch>;
|
|
branches?: Maybe<BranchCollection>;
|
|
collaborators: Array<StreamCollaborator>;
|
|
/**
|
|
* The total number of comments for this stream. To actually get the comments, use the comments query without passing in a resource array. E.g.:
|
|
*
|
|
* ```
|
|
* query{
|
|
* comments(streamId:"streamId"){
|
|
* ...
|
|
* }
|
|
* ```
|
|
*/
|
|
commentCount: Scalars['Int'];
|
|
commit?: Maybe<Commit>;
|
|
commits?: Maybe<CommitCollection>;
|
|
createdAt: Scalars['DateTime'];
|
|
description?: Maybe<Scalars['String']>;
|
|
/** Date when you favorited this stream. `null` if stream isn't viewed from a specific user's perspective or if it isn't favorited. */
|
|
favoritedDate?: Maybe<Scalars['DateTime']>;
|
|
favoritesCount: Scalars['Int'];
|
|
/** Returns a specific file upload that belongs to this stream. */
|
|
fileUpload?: Maybe<FileUpload>;
|
|
/** Returns a list of all the file uploads for this stream. */
|
|
fileUploads?: Maybe<Array<Maybe<FileUpload>>>;
|
|
id: Scalars['String'];
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable: Scalars['Boolean'];
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic: Scalars['Boolean'];
|
|
name: Scalars['String'];
|
|
object?: Maybe<Object>;
|
|
/** Pending stream access requests */
|
|
pendingAccessRequests?: Maybe<Array<StreamAccessRequest>>;
|
|
/** Collaborators who have been invited, but not yet accepted. */
|
|
pendingCollaborators?: Maybe<Array<PendingStreamCollaborator>>;
|
|
/** Your role for this stream. `null` if request is not authenticated, or the stream is not explicitly shared with you. */
|
|
role?: Maybe<Scalars['String']>;
|
|
size?: Maybe<Scalars['String']>;
|
|
updatedAt: Scalars['DateTime'];
|
|
webhooks?: Maybe<WebhookCollection>;
|
|
};
|
|
|
|
|
|
export type StreamActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']>;
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
export type StreamBlobArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type StreamBlobsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: InputMaybe<Scalars['Int']>;
|
|
query?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type StreamBranchArgs = {
|
|
name?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type StreamBranchesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
export type StreamCommitArgs = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type StreamCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
export type StreamFileUploadArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type StreamObjectArgs = {
|
|
id: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type StreamWebhooksArgs = {
|
|
id?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
/** Created when a user requests to become a contributor on a stream */
|
|
export type StreamAccessRequest = {
|
|
__typename?: 'StreamAccessRequest';
|
|
createdAt: Scalars['DateTime'];
|
|
id: Scalars['ID'];
|
|
requester: LimitedUser;
|
|
requesterId: Scalars['String'];
|
|
/** Can only be selected if authed user has proper access */
|
|
stream: Stream;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type StreamCollaborator = {
|
|
__typename?: 'StreamCollaborator';
|
|
avatar?: Maybe<Scalars['String']>;
|
|
company?: Maybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
name: Scalars['String'];
|
|
role: Scalars['String'];
|
|
};
|
|
|
|
export type StreamCollection = {
|
|
__typename?: 'StreamCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<Stream>>;
|
|
totalCount: Scalars['Int'];
|
|
};
|
|
|
|
export type StreamCreateInput = {
|
|
description?: InputMaybe<Scalars['String']>;
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable?: InputMaybe<Scalars['Boolean']>;
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic?: InputMaybe<Scalars['Boolean']>;
|
|
name?: InputMaybe<Scalars['String']>;
|
|
/** Optionally specify user IDs of users that you want to invite to be contributors to this stream */
|
|
withContributors?: InputMaybe<Array<Scalars['String']>>;
|
|
};
|
|
|
|
export type StreamInviteCreateInput = {
|
|
email?: InputMaybe<Scalars['String']>;
|
|
message?: InputMaybe<Scalars['String']>;
|
|
/** Defaults to the contributor role, if not specified */
|
|
role?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
userId?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type StreamRevokePermissionInput = {
|
|
streamId: Scalars['String'];
|
|
userId: Scalars['String'];
|
|
};
|
|
|
|
export enum StreamRole {
|
|
StreamContributor = 'STREAM_CONTRIBUTOR',
|
|
StreamOwner = 'STREAM_OWNER',
|
|
StreamReviewer = 'STREAM_REVIEWER'
|
|
}
|
|
|
|
export type StreamUpdateInput = {
|
|
allowPublicComments?: InputMaybe<Scalars['Boolean']>;
|
|
description?: InputMaybe<Scalars['String']>;
|
|
id: Scalars['String'];
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable?: InputMaybe<Scalars['Boolean']>;
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic?: InputMaybe<Scalars['Boolean']>;
|
|
name?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type StreamUpdatePermissionInput = {
|
|
role: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
userId: Scalars['String'];
|
|
};
|
|
|
|
export type Subscription = {
|
|
__typename?: 'Subscription';
|
|
/** It's lonely in the void. */
|
|
_?: Maybe<Scalars['String']>;
|
|
/** Subscribe to branch created event */
|
|
branchCreated?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribe to branch deleted event */
|
|
branchDeleted?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribe to branch updated event. */
|
|
branchUpdated?: Maybe<Scalars['JSONObject']>;
|
|
/**
|
|
* Subscribe to new comment events. There's two ways to use this subscription:
|
|
* - for a whole stream: do not pass in any resourceIds; this sub will get called whenever a comment (not reply) is added to any of the stream's resources.
|
|
* - for a specific resource/set of resources: pass in a list of resourceIds (commit or object ids); this sub will get called when *any* of the resources provided get a comment.
|
|
*/
|
|
commentActivity: CommentActivityMessage;
|
|
/**
|
|
* Subscribes to events on a specific comment. Use to find out when:
|
|
* - a top level comment is deleted (trigger a deletion event outside)
|
|
* - a top level comment receives a reply.
|
|
*/
|
|
commentThreadActivity: CommentThreadActivityMessage;
|
|
/** Subscribe to commit created event */
|
|
commitCreated?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribe to commit deleted event */
|
|
commitDeleted?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribe to commit updated event. */
|
|
commitUpdated?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribes to stream deleted event. Use this in clients/components that pertain only to this stream. */
|
|
streamDeleted?: Maybe<Scalars['JSONObject']>;
|
|
/** Subscribes to stream updated event. Use this in clients/components that pertain only to this stream. */
|
|
streamUpdated?: Maybe<Scalars['JSONObject']>;
|
|
/**
|
|
* Subscribes to new stream added event for your profile. Use this to display an up-to-date list of streams.
|
|
* **NOTE**: If someone shares a stream with you, this subscription will be triggered with an extra value of `sharedBy` in the payload.
|
|
*/
|
|
userStreamAdded?: Maybe<Scalars['JSONObject']>;
|
|
/**
|
|
* Subscribes to stream removed event for your profile. Use this to display an up-to-date list of streams for your profile.
|
|
* **NOTE**: If someone revokes your permissions on a stream, this subscription will be triggered with an extra value of `revokedBy` in the payload.
|
|
*/
|
|
userStreamRemoved?: Maybe<Scalars['JSONObject']>;
|
|
/** Broadcasts "real-time" location data for viewer users. */
|
|
userViewerActivity?: Maybe<Scalars['JSONObject']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchCreatedArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchDeletedArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchUpdatedArgs = {
|
|
branchId?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommentActivityArgs = {
|
|
resourceIds?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommentThreadActivityArgs = {
|
|
commentId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitCreatedArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitDeletedArgs = {
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitUpdatedArgs = {
|
|
commitId?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type SubscriptionStreamDeletedArgs = {
|
|
streamId?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionStreamUpdatedArgs = {
|
|
streamId?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionUserViewerActivityArgs = {
|
|
resourceId: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type User = {
|
|
__typename?: 'User';
|
|
/** All the recent activity from this user in chronological order */
|
|
activity?: Maybe<ActivityCollection>;
|
|
/** Returns a list of your personal api tokens. */
|
|
apiTokens?: Maybe<Array<Maybe<ApiToken>>>;
|
|
/** Returns the apps you have authorized. */
|
|
authorizedApps?: Maybe<Array<Maybe<ServerAppListItem>>>;
|
|
avatar?: Maybe<Scalars['String']>;
|
|
bio?: Maybe<Scalars['String']>;
|
|
/**
|
|
* Get commits authored by the user. If requested for another user, then only commits
|
|
* from public streams will be returned.
|
|
*/
|
|
commits?: Maybe<CommitCollection>;
|
|
company?: Maybe<Scalars['String']>;
|
|
/** Returns the apps you have created. */
|
|
createdApps?: Maybe<Array<Maybe<ServerApp>>>;
|
|
/**
|
|
* E-mail can be null, if it's requested for a user other than the authenticated one
|
|
* and the user isn't an admin
|
|
*/
|
|
email?: Maybe<Scalars['String']>;
|
|
/**
|
|
* All the streams that a active user has favorited.
|
|
* Note: You can't use this to retrieve another user's favorite streams.
|
|
*/
|
|
favoriteStreams: StreamCollection;
|
|
/** Whether the user has a pending/active email verification token */
|
|
hasPendingVerification?: Maybe<Scalars['Boolean']>;
|
|
id: Scalars['String'];
|
|
name?: Maybe<Scalars['String']>;
|
|
notificationPreferences: Scalars['JSONObject'];
|
|
profiles?: Maybe<Scalars['JSONObject']>;
|
|
role?: Maybe<Scalars['String']>;
|
|
/**
|
|
* Returns all streams that the user is a collaborator on. If requested for a user, who isn't the
|
|
* authenticated user, then this will only return discoverable streams.
|
|
*/
|
|
streams: StreamCollection;
|
|
/** The user's timeline in chronological order */
|
|
timeline?: Maybe<ActivityCollection>;
|
|
/** Total amount of favorites attached to streams owned by the user */
|
|
totalOwnedStreamsFavorites: Scalars['Int'];
|
|
verified?: Maybe<Scalars['Boolean']>;
|
|
};
|
|
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type UserActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']>;
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type UserCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type UserFavoriteStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type UserStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Full user type, should only be used in the context of admin operations or
|
|
* when a user is reading/writing info about himself
|
|
*/
|
|
export type UserTimelineArgs = {
|
|
after?: InputMaybe<Scalars['DateTime']>;
|
|
before?: InputMaybe<Scalars['DateTime']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']>;
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
export type UserDeleteInput = {
|
|
email?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type UserRoleInput = {
|
|
id: Scalars['String'];
|
|
role: Scalars['String'];
|
|
};
|
|
|
|
export type UserSearchResultCollection = {
|
|
__typename?: 'UserSearchResultCollection';
|
|
cursor?: Maybe<Scalars['String']>;
|
|
items?: Maybe<Array<Maybe<LimitedUser>>>;
|
|
};
|
|
|
|
export type UserUpdateInput = {
|
|
avatar?: InputMaybe<Scalars['String']>;
|
|
bio?: InputMaybe<Scalars['String']>;
|
|
company?: InputMaybe<Scalars['String']>;
|
|
name?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type Webhook = {
|
|
__typename?: 'Webhook';
|
|
description?: Maybe<Scalars['String']>;
|
|
enabled?: Maybe<Scalars['Boolean']>;
|
|
history?: Maybe<WebhookEventCollection>;
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
triggers: Array<Maybe<Scalars['String']>>;
|
|
url: Scalars['String'];
|
|
};
|
|
|
|
|
|
export type WebhookHistoryArgs = {
|
|
limit?: Scalars['Int'];
|
|
};
|
|
|
|
export type WebhookCollection = {
|
|
__typename?: 'WebhookCollection';
|
|
items?: Maybe<Array<Maybe<Webhook>>>;
|
|
totalCount?: Maybe<Scalars['Int']>;
|
|
};
|
|
|
|
export type WebhookCreateInput = {
|
|
description?: InputMaybe<Scalars['String']>;
|
|
enabled?: InputMaybe<Scalars['Boolean']>;
|
|
secret?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
triggers: Array<InputMaybe<Scalars['String']>>;
|
|
url: Scalars['String'];
|
|
};
|
|
|
|
export type WebhookDeleteInput = {
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
};
|
|
|
|
export type WebhookEvent = {
|
|
__typename?: 'WebhookEvent';
|
|
id: Scalars['String'];
|
|
lastUpdate: Scalars['DateTime'];
|
|
payload: Scalars['String'];
|
|
retryCount: Scalars['Int'];
|
|
status: Scalars['Int'];
|
|
statusInfo: Scalars['String'];
|
|
webhookId: Scalars['String'];
|
|
};
|
|
|
|
export type WebhookEventCollection = {
|
|
__typename?: 'WebhookEventCollection';
|
|
items?: Maybe<Array<Maybe<WebhookEvent>>>;
|
|
totalCount?: Maybe<Scalars['Int']>;
|
|
};
|
|
|
|
export type WebhookUpdateInput = {
|
|
description?: InputMaybe<Scalars['String']>;
|
|
enabled?: InputMaybe<Scalars['Boolean']>;
|
|
id: Scalars['String'];
|
|
secret?: InputMaybe<Scalars['String']>;
|
|
streamId: Scalars['String'];
|
|
triggers?: InputMaybe<Array<InputMaybe<Scalars['String']>>>;
|
|
url?: InputMaybe<Scalars['String']>;
|
|
};
|
|
|
|
export type BasicStreamAccessRequestFieldsFragment = { __typename?: 'StreamAccessRequest', id: string, requesterId: string, streamId: string, createdAt: string, requester: { __typename?: 'LimitedUser', id: string, name?: string | null } };
|
|
|
|
export type CreateStreamAccessRequestMutationVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type CreateStreamAccessRequestMutation = { __typename?: 'Mutation', streamAccessRequestCreate: { __typename?: 'StreamAccessRequest', id: string, requesterId: string, streamId: string, createdAt: string, requester: { __typename?: 'LimitedUser', id: string, name?: string | null } } };
|
|
|
|
export type GetStreamAccessRequestQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetStreamAccessRequestQuery = { __typename?: 'Query', streamAccessRequest?: { __typename?: 'StreamAccessRequest', id: string, requesterId: string, streamId: string, createdAt: string, requester: { __typename?: 'LimitedUser', id: string, name?: string | null } } | null };
|
|
|
|
export type GetFullStreamAccessRequestQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetFullStreamAccessRequestQuery = { __typename?: 'Query', streamAccessRequest?: { __typename?: 'StreamAccessRequest', id: string, requesterId: string, streamId: string, createdAt: string, stream: { __typename?: 'Stream', id: string, name: string }, requester: { __typename?: 'LimitedUser', id: string, name?: string | null } } | null };
|
|
|
|
export type GetPendingStreamAccessRequestsQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetPendingStreamAccessRequestsQuery = { __typename?: 'Query', stream?: { __typename?: 'Stream', id: string, name: string, pendingAccessRequests?: Array<{ __typename?: 'StreamAccessRequest', id: string, requesterId: string, streamId: string, createdAt: string, stream: { __typename?: 'Stream', id: string, name: string }, requester: { __typename?: 'LimitedUser', id: string, name?: string | null } }> | null } | null };
|
|
|
|
export type UseStreamAccessRequestMutationVariables = Exact<{
|
|
requestId: Scalars['String'];
|
|
accept: Scalars['Boolean'];
|
|
role?: StreamRole;
|
|
}>;
|
|
|
|
|
|
export type UseStreamAccessRequestMutation = { __typename?: 'Mutation', streamAccessRequestUse: boolean };
|
|
|
|
export type CommentWithRepliesFragment = { __typename?: 'Comment', id: string, rawText: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null }, replies?: { __typename?: 'CommentCollection', items: Array<{ __typename?: 'Comment', id: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null } }> } | null };
|
|
|
|
export type CreateCommentMutationVariables = Exact<{
|
|
input: CommentCreateInput;
|
|
}>;
|
|
|
|
|
|
export type CreateCommentMutation = { __typename?: 'Mutation', commentCreate: string };
|
|
|
|
export type CreateReplyMutationVariables = Exact<{
|
|
input: ReplyCreateInput;
|
|
}>;
|
|
|
|
|
|
export type CreateReplyMutation = { __typename?: 'Mutation', commentReply: string };
|
|
|
|
export type GetCommentQueryVariables = Exact<{
|
|
id: Scalars['String'];
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetCommentQuery = { __typename?: 'Query', comment?: { __typename?: 'Comment', id: string, rawText: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null }, replies?: { __typename?: 'CommentCollection', items: Array<{ __typename?: 'Comment', id: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null } }> } | null } | null };
|
|
|
|
export type GetCommentsQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetCommentsQuery = { __typename?: 'Query', comments?: { __typename?: 'CommentCollection', totalCount: number, cursor?: string | null, items: Array<{ __typename?: 'Comment', id: string, rawText: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null }, replies?: { __typename?: 'CommentCollection', items: Array<{ __typename?: 'Comment', id: string, text: { __typename?: 'SmartTextEditorValue', doc?: Record<string, unknown> | null, attachments?: Array<{ __typename?: 'BlobMetadata', id: string, fileName: string, streamId: string }> | null } }> } | null }> } | null };
|
|
|
|
export type BaseCommitFieldsFragment = { __typename?: 'Commit', id: string, authorName?: string | null, authorId?: string | null, authorAvatar?: string | null, streamId?: string | null, streamName?: string | null, sourceApplication?: string | null, message?: string | null, referencedObject: string, createdAt?: string | null, commentCount: number };
|
|
|
|
export type ReadOwnCommitsQueryVariables = Exact<{
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
}>;
|
|
|
|
|
|
export type ReadOwnCommitsQuery = { __typename?: 'Query', activeUser?: { __typename?: 'User', commits?: { __typename?: 'CommitCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Commit', id: string, authorName?: string | null, authorId?: string | null, authorAvatar?: string | null, streamId?: string | null, streamName?: string | null, sourceApplication?: string | null, message?: string | null, referencedObject: string, createdAt?: string | null, commentCount: number }> | null } | null } | null };
|
|
|
|
export type ReadOtherUsersCommitsQueryVariables = Exact<{
|
|
userId: Scalars['String'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
}>;
|
|
|
|
|
|
export type ReadOtherUsersCommitsQuery = { __typename?: 'Query', otherUser?: { __typename?: 'LimitedUser', commits?: { __typename?: 'CommitCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Commit', id: string, authorName?: string | null, authorId?: string | null, authorAvatar?: string | null, streamId?: string | null, streamName?: string | null, sourceApplication?: string | null, message?: string | null, referencedObject: string, createdAt?: string | null, commentCount: number, stream: { __typename?: 'Stream', id: string, name: string, isPublic: boolean } }> | null } | null } | null };
|
|
|
|
export type ReadStreamBranchCommitsQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
branchName: Scalars['String'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
}>;
|
|
|
|
|
|
export type ReadStreamBranchCommitsQuery = { __typename?: 'Query', stream?: { __typename?: 'Stream', id: string, name: string, role?: string | null, branch?: { __typename?: 'Branch', id: string, name: string, description?: string | null, commits?: { __typename?: 'CommitCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Commit', id: string, authorName?: string | null, authorId?: string | null, authorAvatar?: string | null, streamId?: string | null, streamName?: string | null, sourceApplication?: string | null, message?: string | null, referencedObject: string, createdAt?: string | null, commentCount: number }> | null } | null } | null } | null };
|
|
|
|
export type MoveCommitsMutationVariables = Exact<{
|
|
input: CommitsMoveInput;
|
|
}>;
|
|
|
|
|
|
export type MoveCommitsMutation = { __typename?: 'Mutation', commitsMove: boolean };
|
|
|
|
export type DeleteCommitsMutationVariables = Exact<{
|
|
input: CommitsDeleteInput;
|
|
}>;
|
|
|
|
|
|
export type DeleteCommitsMutation = { __typename?: 'Mutation', commitsDelete: boolean };
|
|
|
|
export type CreateServerInviteMutationVariables = Exact<{
|
|
input: ServerInviteCreateInput;
|
|
}>;
|
|
|
|
|
|
export type CreateServerInviteMutation = { __typename?: 'Mutation', serverInviteCreate: boolean };
|
|
|
|
export type CreateStreamInviteMutationVariables = Exact<{
|
|
input: StreamInviteCreateInput;
|
|
}>;
|
|
|
|
|
|
export type CreateStreamInviteMutation = { __typename?: 'Mutation', streamInviteCreate: boolean };
|
|
|
|
export type ResendInviteMutationVariables = Exact<{
|
|
inviteId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type ResendInviteMutation = { __typename?: 'Mutation', inviteResend: boolean };
|
|
|
|
export type BatchCreateServerInviteMutationVariables = Exact<{
|
|
input: Array<ServerInviteCreateInput> | ServerInviteCreateInput;
|
|
}>;
|
|
|
|
|
|
export type BatchCreateServerInviteMutation = { __typename?: 'Mutation', serverInviteBatchCreate: boolean };
|
|
|
|
export type BatchCreateStreamInviteMutationVariables = Exact<{
|
|
input: Array<StreamInviteCreateInput> | StreamInviteCreateInput;
|
|
}>;
|
|
|
|
|
|
export type BatchCreateStreamInviteMutation = { __typename?: 'Mutation', streamInviteBatchCreate: boolean };
|
|
|
|
export type DeleteInviteMutationVariables = Exact<{
|
|
inviteId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type DeleteInviteMutation = { __typename?: 'Mutation', inviteDelete: boolean };
|
|
|
|
export type StreamInviteDataFragment = { __typename?: 'PendingStreamCollaborator', id: string, inviteId: string, streamId: string, title: string, role: string, token?: string | null, invitedBy: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null }, user?: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null } | null };
|
|
|
|
export type GetStreamInviteQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
token?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetStreamInviteQuery = { __typename?: 'Query', streamInvite?: { __typename?: 'PendingStreamCollaborator', id: string, inviteId: string, streamId: string, title: string, role: string, token?: string | null, invitedBy: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null }, user?: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null } | null } | null };
|
|
|
|
export type GetStreamInvitesQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type GetStreamInvitesQuery = { __typename?: 'Query', streamInvites: Array<{ __typename?: 'PendingStreamCollaborator', id: string, inviteId: string, streamId: string, title: string, role: string, token?: string | null, invitedBy: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null }, user?: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null } | null }> };
|
|
|
|
export type UseStreamInviteMutationVariables = Exact<{
|
|
accept: Scalars['Boolean'];
|
|
streamId: Scalars['String'];
|
|
token: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type UseStreamInviteMutation = { __typename?: 'Mutation', streamInviteUse: boolean };
|
|
|
|
export type CancelStreamInviteMutationVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
inviteId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type CancelStreamInviteMutation = { __typename?: 'Mutation', streamInviteCancel: boolean };
|
|
|
|
export type GetStreamPendingCollaboratorsQueryVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetStreamPendingCollaboratorsQuery = { __typename?: 'Query', stream?: { __typename?: 'Stream', id: string, pendingCollaborators?: Array<{ __typename?: 'PendingStreamCollaborator', inviteId: string, title: string, token?: string | null, user?: { __typename?: 'LimitedUser', id: string, name?: string | null } | null }> | null } | null };
|
|
|
|
export type BasicStreamFieldsFragment = { __typename?: 'Stream', id: string, name: string, description?: string | null, isPublic: boolean, isDiscoverable: boolean, allowPublicComments: boolean, role?: string | null, createdAt: string, updatedAt: string };
|
|
|
|
export type LeaveStreamMutationVariables = Exact<{
|
|
streamId: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type LeaveStreamMutation = { __typename?: 'Mutation', streamLeave: boolean };
|
|
|
|
export type CreateStreamMutationVariables = Exact<{
|
|
stream: StreamCreateInput;
|
|
}>;
|
|
|
|
|
|
export type CreateStreamMutation = { __typename?: 'Mutation', streamCreate?: string | null };
|
|
|
|
export type UpdateStreamMutationVariables = Exact<{
|
|
stream: StreamUpdateInput;
|
|
}>;
|
|
|
|
|
|
export type UpdateStreamMutation = { __typename?: 'Mutation', streamUpdate: boolean };
|
|
|
|
export type ReadStreamQueryVariables = Exact<{
|
|
id: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type ReadStreamQuery = { __typename?: 'Query', stream?: { __typename?: 'Stream', id: string, name: string, description?: string | null, isPublic: boolean, isDiscoverable: boolean, allowPublicComments: boolean, role?: string | null, createdAt: string, updatedAt: string } | null };
|
|
|
|
export type ReadDiscoverableStreamsQueryVariables = Exact<{
|
|
limit?: Scalars['Int'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
sort?: InputMaybe<DiscoverableStreamsSortingInput>;
|
|
}>;
|
|
|
|
|
|
export type ReadDiscoverableStreamsQuery = { __typename?: 'Query', discoverableStreams?: { __typename?: 'StreamCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Stream', favoritesCount: number, id: string, name: string, description?: string | null, isPublic: boolean, isDiscoverable: boolean, allowPublicComments: boolean, role?: string | null, createdAt: string, updatedAt: string }> | null } | null };
|
|
|
|
export type GetUserStreamsQueryVariables = Exact<{
|
|
userId?: InputMaybe<Scalars['String']>;
|
|
limit?: Scalars['Int'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetUserStreamsQuery = { __typename?: 'Query', user?: { __typename?: 'User', streams: { __typename?: 'StreamCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Stream', id: string, name: string, description?: string | null, isPublic: boolean, isDiscoverable: boolean, allowPublicComments: boolean, role?: string | null, createdAt: string, updatedAt: string }> | null } } | null };
|
|
|
|
export type GetLimitedUserStreamsQueryVariables = Exact<{
|
|
userId: Scalars['String'];
|
|
limit?: Scalars['Int'];
|
|
cursor?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetLimitedUserStreamsQuery = { __typename?: 'Query', otherUser?: { __typename?: 'LimitedUser', streams: { __typename?: 'StreamCollection', totalCount: number, cursor?: string | null, items?: Array<{ __typename?: 'Stream', id: string, name: string, description?: string | null, isPublic: boolean, isDiscoverable: boolean, allowPublicComments: boolean, role?: string | null, createdAt: string, updatedAt: string }> | null } } | null };
|
|
|
|
export type BaseUserFieldsFragment = { __typename?: 'User', id: string, email?: string | null, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null, role?: string | null };
|
|
|
|
export type BaseLimitedUserFieldsFragment = { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null };
|
|
|
|
export type GetActiveUserQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type GetActiveUserQuery = { __typename?: 'Query', activeUser?: { __typename?: 'User', id: string, email?: string | null, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null, role?: string | null } | null };
|
|
|
|
export type GetOtherUserQueryVariables = Exact<{
|
|
id: Scalars['String'];
|
|
}>;
|
|
|
|
|
|
export type GetOtherUserQuery = { __typename?: 'Query', otherUser?: { __typename?: 'LimitedUser', id: string, name?: string | null, bio?: string | null, company?: string | null, avatar?: string | null, verified?: boolean | null } | null };
|
|
|
|
export type GetAdminUsersQueryVariables = Exact<{
|
|
limit?: Scalars['Int'];
|
|
offset?: Scalars['Int'];
|
|
query?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetAdminUsersQuery = { __typename?: 'Query', adminUsers?: { __typename?: 'AdminUsersListCollection', totalCount: number, items: Array<{ __typename?: 'AdminUsersListItem', id: string, registeredUser?: { __typename?: 'User', id: string, email?: string | null, name?: string | null } | null, invitedUser?: { __typename?: 'ServerInvite', id: string, email: string, invitedBy: { __typename?: 'LimitedUser', id: string, name?: string | null } } | null }> } | null };
|
|
|
|
export type GetPendingEmailVerificationStatusQueryVariables = Exact<{
|
|
id?: InputMaybe<Scalars['String']>;
|
|
}>;
|
|
|
|
|
|
export type GetPendingEmailVerificationStatusQuery = { __typename?: 'Query', user?: { __typename?: 'User', hasPendingVerification?: boolean | null } | null };
|
|
|
|
export type RequestVerificationMutationVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type RequestVerificationMutation = { __typename?: 'Mutation', requestVerification: boolean };
|