Kristaps Fabians Geikins
211922b6a6
* first batch of changes * tests fix * FE fixed * renaming constants * test fixes * moar test fixes * another test fix * reenable app rover check --------- Co-authored-by: Gergő Jedlicska <gergo@jedlicska.com>
5084 lines
159 KiB
TypeScript
5084 lines
159 KiB
TypeScript
/* eslint-disable */
|
|
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
|
|
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]> };
|
|
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
|
|
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: { input: string; output: string; }
|
|
String: { input: string; output: string; }
|
|
Boolean: { input: boolean; output: boolean; }
|
|
Int: { input: number; output: number; }
|
|
Float: { input: number; output: number; }
|
|
/** The `BigInt` scalar type represents non-fractional signed whole numeric values. */
|
|
BigInt: { input: any; output: any; }
|
|
/** 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: { input: string; output: string; }
|
|
/** 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: { input: {}; output: {}; }
|
|
};
|
|
|
|
export type ActiveUserMutations = {
|
|
__typename?: 'ActiveUserMutations';
|
|
emailMutations: UserEmailMutations;
|
|
/** Mark onboarding as complete */
|
|
finishOnboarding: Scalars['Boolean']['output'];
|
|
meta: UserMetaMutations;
|
|
setActiveWorkspace: Scalars['Boolean']['output'];
|
|
/** Edit a user's profile */
|
|
update: User;
|
|
};
|
|
|
|
|
|
export type ActiveUserMutationsFinishOnboardingArgs = {
|
|
input?: InputMaybe<OnboardingCompletionInput>;
|
|
};
|
|
|
|
|
|
export type ActiveUserMutationsSetActiveWorkspaceArgs = {
|
|
isProjectsActive?: InputMaybe<Scalars['Boolean']['input']>;
|
|
slug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type ActiveUserMutationsUpdateArgs = {
|
|
user: UserUpdateInput;
|
|
};
|
|
|
|
export type Activity = {
|
|
__typename?: 'Activity';
|
|
actionType: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
info: Scalars['JSONObject']['output'];
|
|
message: Scalars['String']['output'];
|
|
resourceId: Scalars['String']['output'];
|
|
resourceType: Scalars['String']['output'];
|
|
streamId?: Maybe<Scalars['String']['output']>;
|
|
time: Scalars['DateTime']['output'];
|
|
userId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ActivityCollection = {
|
|
__typename?: 'ActivityCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Activity>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AddDomainToWorkspaceInput = {
|
|
domain: Scalars['String']['input'];
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type AdminInviteList = {
|
|
__typename?: 'AdminInviteList';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<ServerInvite>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AdminMutations = {
|
|
__typename?: 'AdminMutations';
|
|
updateWorkspacePlan: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type AdminMutationsUpdateWorkspacePlanArgs = {
|
|
input: AdminUpdateWorkspacePlanInput;
|
|
};
|
|
|
|
export type AdminQueries = {
|
|
__typename?: 'AdminQueries';
|
|
inviteList: AdminInviteList;
|
|
projectList: ProjectCollection;
|
|
serverStatistics: ServerStatistics;
|
|
userList: AdminUserList;
|
|
workspaceList: WorkspaceCollection;
|
|
};
|
|
|
|
|
|
export type AdminQueriesInviteListArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type AdminQueriesProjectListArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
orderBy?: InputMaybe<Scalars['String']['input']>;
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
visibility?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type AdminQueriesUserListArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
role?: InputMaybe<ServerRole>;
|
|
};
|
|
|
|
|
|
export type AdminQueriesWorkspaceListArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AdminUpdateWorkspacePlanInput = {
|
|
plan: WorkspacePlans;
|
|
status: WorkspacePlanStatuses;
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type AdminUserList = {
|
|
__typename?: 'AdminUserList';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<AdminUserListItem>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AdminUserListItem = {
|
|
__typename?: 'AdminUserListItem';
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
company?: Maybe<Scalars['String']['output']>;
|
|
email?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
name: Scalars['String']['output'];
|
|
role?: Maybe<Scalars['String']['output']>;
|
|
verified?: Maybe<Scalars['Boolean']['output']>;
|
|
};
|
|
|
|
export type AdminUsersListCollection = {
|
|
__typename?: 'AdminUsersListCollection';
|
|
items: Array<AdminUsersListItem>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
/**
|
|
* 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']['output'];
|
|
invitedUser?: Maybe<ServerInvite>;
|
|
registeredUser?: Maybe<User>;
|
|
};
|
|
|
|
export type AdminWorkspaceJoinRequestFilter = {
|
|
status?: InputMaybe<WorkspaceJoinRequestStatus>;
|
|
};
|
|
|
|
export type ApiToken = {
|
|
__typename?: 'ApiToken';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['String']['output'];
|
|
lastChars: Scalars['String']['output'];
|
|
lastUsed: Scalars['DateTime']['output'];
|
|
lifespan: Scalars['BigInt']['output'];
|
|
name: Scalars['String']['output'];
|
|
scopes: Array<Maybe<Scalars['String']['output']>>;
|
|
};
|
|
|
|
export type ApiTokenCreateInput = {
|
|
lifespan?: InputMaybe<Scalars['BigInt']['input']>;
|
|
name: Scalars['String']['input'];
|
|
scopes: Array<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AppAuthor = {
|
|
__typename?: 'AppAuthor';
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type AppCreateInput = {
|
|
description: Scalars['String']['input'];
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
public?: InputMaybe<Scalars['Boolean']['input']>;
|
|
redirectUrl: Scalars['String']['input'];
|
|
scopes: Array<InputMaybe<Scalars['String']['input']>>;
|
|
termsAndConditionsLink?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AppTokenCreateInput = {
|
|
lifespan?: InputMaybe<Scalars['BigInt']['input']>;
|
|
/** Optionally limit the token to only have access to specific resources */
|
|
limitResources?: InputMaybe<Array<TokenResourceIdentifierInput>>;
|
|
name: Scalars['String']['input'];
|
|
scopes: Array<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AppUpdateInput = {
|
|
description: Scalars['String']['input'];
|
|
id: Scalars['String']['input'];
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
public?: InputMaybe<Scalars['Boolean']['input']>;
|
|
redirectUrl: Scalars['String']['input'];
|
|
scopes: Array<InputMaybe<Scalars['String']['input']>>;
|
|
termsAndConditionsLink?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ApproveWorkspaceJoinRequestInput = {
|
|
userId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ArchiveCommentInput = {
|
|
archived: Scalars['Boolean']['input'];
|
|
commentId: Scalars['String']['input'];
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type AuthStrategy = {
|
|
__typename?: 'AuthStrategy';
|
|
color?: Maybe<Scalars['String']['output']>;
|
|
icon: Scalars['String']['output'];
|
|
id: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
export type AutomateAuthCodePayloadTest = {
|
|
action: Scalars['String']['input'];
|
|
code: Scalars['String']['input'];
|
|
userId: Scalars['String']['input'];
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
/** Additional resources to validate user access to. */
|
|
export type AutomateAuthCodeResources = {
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AutomateFunction = {
|
|
__typename?: 'AutomateFunction';
|
|
/** Only returned if user is a part of this speckle server */
|
|
creator?: Maybe<LimitedUser>;
|
|
description: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
isFeatured: Scalars['Boolean']['output'];
|
|
logo?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
releases: AutomateFunctionReleaseCollection;
|
|
repo: BasicGitRepositoryMetadata;
|
|
/** SourceAppNames values from @speckle/shared. Empty array means - all of them */
|
|
supportedSourceApps: Array<Scalars['String']['output']>;
|
|
tags: Array<Scalars['String']['output']>;
|
|
workspaceIds?: Maybe<Array<Scalars['String']['output']>>;
|
|
};
|
|
|
|
|
|
export type AutomateFunctionReleasesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<AutomateFunctionReleasesFilter>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type AutomateFunctionCollection = {
|
|
__typename?: 'AutomateFunctionCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<AutomateFunction>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AutomateFunctionRelease = {
|
|
__typename?: 'AutomateFunctionRelease';
|
|
commitId: Scalars['String']['output'];
|
|
createdAt: Scalars['DateTime']['output'];
|
|
function: AutomateFunction;
|
|
functionId: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
inputSchema?: Maybe<Scalars['JSONObject']['output']>;
|
|
versionTag: Scalars['String']['output'];
|
|
};
|
|
|
|
export type AutomateFunctionReleaseCollection = {
|
|
__typename?: 'AutomateFunctionReleaseCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<AutomateFunctionRelease>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AutomateFunctionReleasesFilter = {
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AutomateFunctionRun = {
|
|
__typename?: 'AutomateFunctionRun';
|
|
contextView?: Maybe<Scalars['String']['output']>;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
elapsed: Scalars['Float']['output'];
|
|
/** Nullable, in case the function is not retrievable due to poor network conditions */
|
|
function?: Maybe<AutomateFunction>;
|
|
functionId?: Maybe<Scalars['String']['output']>;
|
|
functionReleaseId?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
/** AutomateTypes.ResultsSchema type from @speckle/shared */
|
|
results?: Maybe<Scalars['JSONObject']['output']>;
|
|
status: AutomateRunStatus;
|
|
statusMessage?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
export type AutomateFunctionRunStatusReportInput = {
|
|
contextView?: InputMaybe<Scalars['String']['input']>;
|
|
functionRunId: Scalars['String']['input'];
|
|
projectId: Scalars['String']['input'];
|
|
/** AutomateTypes.ResultsSchema type from @speckle/shared */
|
|
results?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
status: AutomateRunStatus;
|
|
statusMessage?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AutomateFunctionTemplate = {
|
|
__typename?: 'AutomateFunctionTemplate';
|
|
id: AutomateFunctionTemplateLanguage;
|
|
logo: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
export enum AutomateFunctionTemplateLanguage {
|
|
DotNet = 'DOT_NET',
|
|
Python = 'PYTHON',
|
|
Typescript = 'TYPESCRIPT'
|
|
}
|
|
|
|
export type AutomateFunctionToken = {
|
|
__typename?: 'AutomateFunctionToken';
|
|
functionId: Scalars['String']['output'];
|
|
functionToken: Scalars['String']['output'];
|
|
};
|
|
|
|
export type AutomateFunctionsFilter = {
|
|
/** By default, we include featured ("public") functions. Set this to false to exclude them. */
|
|
includeFeatured?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** By default, we exclude functions without releases. Set this to false to include them. */
|
|
requireRelease?: InputMaybe<Scalars['Boolean']['input']>;
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AutomateMutations = {
|
|
__typename?: 'AutomateMutations';
|
|
createFunction: AutomateFunction;
|
|
createFunctionWithoutVersion: AutomateFunctionToken;
|
|
updateFunction: AutomateFunction;
|
|
};
|
|
|
|
|
|
export type AutomateMutationsCreateFunctionArgs = {
|
|
input: CreateAutomateFunctionInput;
|
|
};
|
|
|
|
|
|
export type AutomateMutationsCreateFunctionWithoutVersionArgs = {
|
|
input: CreateAutomateFunctionWithoutVersionInput;
|
|
};
|
|
|
|
|
|
export type AutomateMutationsUpdateFunctionArgs = {
|
|
input: UpdateAutomateFunctionInput;
|
|
};
|
|
|
|
export type AutomateRun = {
|
|
__typename?: 'AutomateRun';
|
|
automation: Automation;
|
|
automationId: Scalars['String']['output'];
|
|
createdAt: Scalars['DateTime']['output'];
|
|
functionRuns: Array<AutomateFunctionRun>;
|
|
id: Scalars['ID']['output'];
|
|
status: AutomateRunStatus;
|
|
trigger: AutomationRunTrigger;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
export type AutomateRunCollection = {
|
|
__typename?: 'AutomateRunCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<AutomateRun>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export enum AutomateRunStatus {
|
|
Canceled = 'CANCELED',
|
|
Exception = 'EXCEPTION',
|
|
Failed = 'FAILED',
|
|
Initializing = 'INITIALIZING',
|
|
Pending = 'PENDING',
|
|
Running = 'RUNNING',
|
|
Succeeded = 'SUCCEEDED',
|
|
Timeout = 'TIMEOUT'
|
|
}
|
|
|
|
export enum AutomateRunTriggerType {
|
|
VersionCreated = 'VERSION_CREATED'
|
|
}
|
|
|
|
export type Automation = {
|
|
__typename?: 'Automation';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
/** Only accessible to automation owners */
|
|
creationPublicKeys: Array<Scalars['String']['output']>;
|
|
currentRevision?: Maybe<AutomationRevision>;
|
|
enabled: Scalars['Boolean']['output'];
|
|
id: Scalars['ID']['output'];
|
|
isTestAutomation: Scalars['Boolean']['output'];
|
|
name: Scalars['String']['output'];
|
|
permissions: AutomationPermissionChecks;
|
|
runs: AutomateRunCollection;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
|
|
export type AutomationRunsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type AutomationCollection = {
|
|
__typename?: 'AutomationCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Automation>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type AutomationPermissionChecks = {
|
|
__typename?: 'AutomationPermissionChecks';
|
|
canDelete: PermissionCheckResult;
|
|
canRead: PermissionCheckResult;
|
|
canUpdate: PermissionCheckResult;
|
|
};
|
|
|
|
export type AutomationRevision = {
|
|
__typename?: 'AutomationRevision';
|
|
functions: Array<AutomationRevisionFunction>;
|
|
id: Scalars['ID']['output'];
|
|
triggerDefinitions: Array<AutomationRevisionTriggerDefinition>;
|
|
};
|
|
|
|
export type AutomationRevisionCreateFunctionInput = {
|
|
functionId: Scalars['String']['input'];
|
|
functionReleaseId: Scalars['String']['input'];
|
|
/** Should be encrypted from the client side */
|
|
parameters?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type AutomationRevisionFunction = {
|
|
__typename?: 'AutomationRevisionFunction';
|
|
/** The secrets in parameters are redacted with six asterisks - ****** */
|
|
parameters?: Maybe<Scalars['JSONObject']['output']>;
|
|
release: AutomateFunctionRelease;
|
|
};
|
|
|
|
export type AutomationRevisionTriggerDefinition = VersionCreatedTriggerDefinition;
|
|
|
|
export type AutomationRunTrigger = VersionCreatedTrigger;
|
|
|
|
export type BasicGitRepositoryMetadata = {
|
|
__typename?: 'BasicGitRepositoryMetadata';
|
|
id: Scalars['ID']['output'];
|
|
name: Scalars['String']['output'];
|
|
owner: Scalars['String']['output'];
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
export enum BillingInterval {
|
|
Monthly = 'monthly',
|
|
Yearly = 'yearly'
|
|
}
|
|
|
|
export type BlobMetadata = {
|
|
__typename?: 'BlobMetadata';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
fileHash?: Maybe<Scalars['String']['output']>;
|
|
fileName: Scalars['String']['output'];
|
|
fileSize?: Maybe<Scalars['Int']['output']>;
|
|
fileType: Scalars['String']['output'];
|
|
id: Scalars['String']['output'];
|
|
streamId: Scalars['String']['output'];
|
|
uploadError?: Maybe<Scalars['String']['output']>;
|
|
uploadStatus: Scalars['Int']['output'];
|
|
userId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type BlobMetadataCollection = {
|
|
__typename?: 'BlobMetadataCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items?: Maybe<Array<BlobMetadata>>;
|
|
totalCount: Scalars['Int']['output'];
|
|
totalSize: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type Branch = {
|
|
__typename?: 'Branch';
|
|
/**
|
|
* All the recent activity on this branch in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
activity?: Maybe<ActivityCollection>;
|
|
author?: Maybe<User>;
|
|
commits?: Maybe<CommitCollection>;
|
|
createdAt?: Maybe<Scalars['DateTime']['output']>;
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
|
|
export type BranchActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']['input']>;
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type BranchCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type BranchCollection = {
|
|
__typename?: 'BranchCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items?: Maybe<Array<Branch>>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type BranchCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type BranchDeleteInput = {
|
|
id: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type BranchUpdateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['String']['input'];
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type BulkUsersRetrievalInput = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
emails: Array<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type CancelCheckoutSessionInput = {
|
|
sessionId: Scalars['ID']['input'];
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type CheckoutSession = {
|
|
__typename?: 'CheckoutSession';
|
|
billingInterval: BillingInterval;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['ID']['output'];
|
|
paymentStatus: SessionPaymentStatus;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
url: Scalars['String']['output'];
|
|
workspacePlan: PaidWorkspacePlans;
|
|
};
|
|
|
|
export type CheckoutSessionInput = {
|
|
billingInterval: BillingInterval;
|
|
currency?: InputMaybe<Currency>;
|
|
isCreateFlow?: InputMaybe<Scalars['Boolean']['input']>;
|
|
workspaceId: Scalars['ID']['input'];
|
|
workspacePlan: PaidWorkspacePlans;
|
|
};
|
|
|
|
export type Comment = {
|
|
__typename?: 'Comment';
|
|
archived: Scalars['Boolean']['output'];
|
|
author: LimitedUser;
|
|
authorId: Scalars['String']['output'];
|
|
createdAt: Scalars['DateTime']['output'];
|
|
/**
|
|
* Legacy comment viewer data field
|
|
* @deprecated Use the new viewerState field instead
|
|
*/
|
|
data?: Maybe<Scalars['JSONObject']['output']>;
|
|
/** Whether or not comment is a reply to another comment */
|
|
hasParent: Scalars['Boolean']['output'];
|
|
id: Scalars['String']['output'];
|
|
/** Parent thread, if there's any */
|
|
parent?: Maybe<Comment>;
|
|
permissions: CommentPermissionChecks;
|
|
/** Plain-text version of the comment text, ideal for previews */
|
|
rawText?: Maybe<Scalars['String']['output']>;
|
|
/** @deprecated Not actually implemented */
|
|
reactions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
|
|
/** Gets the replies to this comment. */
|
|
replies: CommentCollection;
|
|
/** Get authors of replies to this comment */
|
|
replyAuthors: CommentReplyAuthorCollection;
|
|
/** 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']['output']>;
|
|
text?: Maybe<SmartTextEditorValue>;
|
|
/** The time this comment was last updated. Corresponds also to the latest reply to this comment, if any. */
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
/** 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']['output']>;
|
|
/** Resource identifiers as defined and implemented in the Viewer of the new frontend */
|
|
viewerResources: Array<ViewerResourceItem>;
|
|
/** SerializedViewerState */
|
|
viewerState?: Maybe<Scalars['JSONObject']['output']>;
|
|
};
|
|
|
|
|
|
export type CommentRepliesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type CommentReplyAuthorsArgs = {
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type CommentActivityMessage = {
|
|
__typename?: 'CommentActivityMessage';
|
|
comment: Comment;
|
|
type: Scalars['String']['output'];
|
|
};
|
|
|
|
export type CommentCollection = {
|
|
__typename?: 'CommentCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Comment>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type CommentContentInput = {
|
|
blobIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
doc?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
/** Deprecated: Used by old stream-based mutations */
|
|
export type CommentCreateInput = {
|
|
/** IDs of uploaded blobs that should be attached to this comment */
|
|
blobIds: Array<Scalars['String']['input']>;
|
|
data: Scalars['JSONObject']['input'];
|
|
/**
|
|
* 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']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
export type CommentDataFilters = {
|
|
__typename?: 'CommentDataFilters';
|
|
hiddenIds?: Maybe<Array<Scalars['String']['output']>>;
|
|
isolatedIds?: Maybe<Array<Scalars['String']['output']>>;
|
|
passMax?: Maybe<Scalars['Float']['output']>;
|
|
passMin?: Maybe<Scalars['Float']['output']>;
|
|
propertyInfoKey?: Maybe<Scalars['String']['output']>;
|
|
sectionBox?: Maybe<Scalars['JSONObject']['output']>;
|
|
};
|
|
|
|
/** Equivalent to frontend-1's LocalFilterState */
|
|
export type CommentDataFiltersInput = {
|
|
hiddenIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
isolatedIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
passMax?: InputMaybe<Scalars['Float']['input']>;
|
|
passMin?: InputMaybe<Scalars['Float']['input']>;
|
|
propertyInfoKey?: InputMaybe<Scalars['String']['input']>;
|
|
sectionBox?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
/** Deprecated: Used by old stream-based mutations */
|
|
export type CommentEditInput = {
|
|
/** IDs of uploaded blobs that should be attached to this comment */
|
|
blobIds: Array<Scalars['String']['input']>;
|
|
id: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
export type CommentMutations = {
|
|
__typename?: 'CommentMutations';
|
|
archive: Scalars['Boolean']['output'];
|
|
create: Comment;
|
|
edit: Comment;
|
|
markViewed: Scalars['Boolean']['output'];
|
|
reply: Comment;
|
|
};
|
|
|
|
|
|
export type CommentMutationsArchiveArgs = {
|
|
input: ArchiveCommentInput;
|
|
};
|
|
|
|
|
|
export type CommentMutationsCreateArgs = {
|
|
input: CreateCommentInput;
|
|
};
|
|
|
|
|
|
export type CommentMutationsEditArgs = {
|
|
input: EditCommentInput;
|
|
};
|
|
|
|
|
|
export type CommentMutationsMarkViewedArgs = {
|
|
input: MarkCommentViewedInput;
|
|
};
|
|
|
|
|
|
export type CommentMutationsReplyArgs = {
|
|
input: CreateCommentReplyInput;
|
|
};
|
|
|
|
export type CommentPermissionChecks = {
|
|
__typename?: 'CommentPermissionChecks';
|
|
canArchive: PermissionCheckResult;
|
|
};
|
|
|
|
export type CommentReplyAuthorCollection = {
|
|
__typename?: 'CommentReplyAuthorCollection';
|
|
items: Array<LimitedUser>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type CommentThreadActivityMessage = {
|
|
__typename?: 'CommentThreadActivityMessage';
|
|
data?: Maybe<Scalars['JSONObject']['output']>;
|
|
reply?: Maybe<Comment>;
|
|
type: Scalars['String']['output'];
|
|
};
|
|
|
|
export type Commit = {
|
|
__typename?: 'Commit';
|
|
/**
|
|
* All the recent activity on this commit in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
activity?: Maybe<ActivityCollection>;
|
|
authorAvatar?: Maybe<Scalars['String']['output']>;
|
|
authorId?: Maybe<Scalars['String']['output']>;
|
|
authorName?: Maybe<Scalars['String']['output']>;
|
|
branch?: Maybe<Branch>;
|
|
branchName?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* 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"}] ){
|
|
* ...
|
|
* }
|
|
* ```
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
commentCount: Scalars['Int']['output'];
|
|
createdAt?: Maybe<Scalars['DateTime']['output']>;
|
|
id: Scalars['String']['output'];
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
parents?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
|
|
referencedObject: Scalars['String']['output'];
|
|
sourceApplication?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* 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']['output']>;
|
|
/** @deprecated Use the stream field instead */
|
|
streamName?: Maybe<Scalars['String']['output']>;
|
|
totalChildrenCount?: Maybe<Scalars['Int']['output']>;
|
|
};
|
|
|
|
|
|
export type CommitActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']['input']>;
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type CommitCollection = {
|
|
__typename?: 'CommitCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items?: Maybe<Array<Commit>>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type CommitCreateInput = {
|
|
branchName: Scalars['String']['input'];
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
objectId: Scalars['String']['input'];
|
|
parents?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
sourceApplication?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
totalChildrenCount?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type CommitDeleteInput = {
|
|
id: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CommitReceivedInput = {
|
|
commitId: Scalars['String']['input'];
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
sourceApplication: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CommitUpdateInput = {
|
|
id: Scalars['String']['input'];
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
/** To move the commit to a different branch, please the name of the branch. */
|
|
newBranchName?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CommitsDeleteInput = {
|
|
commitIds: Array<Scalars['String']['input']>;
|
|
streamId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type CommitsMoveInput = {
|
|
commitIds: Array<Scalars['String']['input']>;
|
|
streamId: Scalars['ID']['input'];
|
|
targetBranch: Scalars['String']['input'];
|
|
};
|
|
|
|
/**
|
|
* Can be used instead of a full item collection, when the implementation doesn't call for it yet. Because
|
|
* of the structure, it can be swapped out to a full item collection in the future
|
|
*/
|
|
export type CountOnlyCollection = {
|
|
__typename?: 'CountOnlyCollection';
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type CreateAutomateFunctionInput = {
|
|
description: Scalars['String']['input'];
|
|
/** Base64 encoded image data string */
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
/** GitHub organization to create the repository in */
|
|
org?: InputMaybe<Scalars['String']['input']>;
|
|
/** SourceAppNames values from @speckle/shared */
|
|
supportedSourceApps: Array<Scalars['String']['input']>;
|
|
tags: Array<Scalars['String']['input']>;
|
|
template: AutomateFunctionTemplateLanguage;
|
|
};
|
|
|
|
export type CreateAutomateFunctionWithoutVersionInput = {
|
|
description: Scalars['String']['input'];
|
|
name: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateCommentInput = {
|
|
content: CommentContentInput;
|
|
projectId: Scalars['String']['input'];
|
|
/** Resources that this comment should be attached to */
|
|
resourceIdString: Scalars['String']['input'];
|
|
screenshot?: InputMaybe<Scalars['String']['input']>;
|
|
/**
|
|
* SerializedViewerState. If omitted, comment won't render (correctly) inside the
|
|
* viewer, but will still be retrievable through the API
|
|
*/
|
|
viewerState?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
export type CreateCommentReplyInput = {
|
|
content: CommentContentInput;
|
|
projectId: Scalars['String']['input'];
|
|
threadId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateModelInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type CreateServerRegionInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
key: Scalars['String']['input'];
|
|
name: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateUserEmailInput = {
|
|
email: Scalars['String']['input'];
|
|
};
|
|
|
|
export type CreateVersionInput = {
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
modelId: Scalars['String']['input'];
|
|
objectId: Scalars['String']['input'];
|
|
parents?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
projectId: Scalars['String']['input'];
|
|
sourceApplication?: InputMaybe<Scalars['String']['input']>;
|
|
totalChildrenCount?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export enum Currency {
|
|
Gbp = 'gbp',
|
|
Usd = 'usd'
|
|
}
|
|
|
|
export type CurrencyBasedPrices = {
|
|
__typename?: 'CurrencyBasedPrices';
|
|
gbp: WorkspacePaidPlanPrices;
|
|
usd: WorkspacePaidPlanPrices;
|
|
};
|
|
|
|
export type DeleteModelInput = {
|
|
id: Scalars['ID']['input'];
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type DeleteUserEmailInput = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type DeleteVersionsInput = {
|
|
projectId: Scalars['ID']['input'];
|
|
versionIds: Array<Scalars['ID']['input']>;
|
|
};
|
|
|
|
export type DenyWorkspaceJoinRequestInput = {
|
|
userId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export enum DiscoverableStreamsSortType {
|
|
CreatedDate = 'CREATED_DATE',
|
|
FavoritesCount = 'FAVORITES_COUNT'
|
|
}
|
|
|
|
export type DiscoverableStreamsSortingInput = {
|
|
direction: SortDirection;
|
|
type: DiscoverableStreamsSortType;
|
|
};
|
|
|
|
export type DiscoverableWorkspaceCollaborator = {
|
|
__typename?: 'DiscoverableWorkspaceCollaborator';
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
export type DiscoverableWorkspaceCollaboratorCollection = {
|
|
__typename?: 'DiscoverableWorkspaceCollaboratorCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<DiscoverableWorkspaceCollaborator>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type EditCommentInput = {
|
|
commentId: Scalars['String']['input'];
|
|
content: CommentContentInput;
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type EmailVerificationRequestInput = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type FileUpload = {
|
|
__typename?: 'FileUpload';
|
|
branchName: Scalars['String']['output'];
|
|
/** If present, the conversion result is stored in this commit. */
|
|
convertedCommitId?: Maybe<Scalars['String']['output']>;
|
|
convertedLastUpdate: Scalars['DateTime']['output'];
|
|
/** Holds any errors or info. */
|
|
convertedMessage?: Maybe<Scalars['String']['output']>;
|
|
/** 0 = queued, 1 = processing, 2 = success, 3 = error */
|
|
convertedStatus: Scalars['Int']['output'];
|
|
/** Alias for convertedCommitId */
|
|
convertedVersionId?: Maybe<Scalars['String']['output']>;
|
|
fileName: Scalars['String']['output'];
|
|
fileSize: Scalars['Int']['output'];
|
|
fileType: Scalars['String']['output'];
|
|
id: Scalars['String']['output'];
|
|
/** Model associated with the file upload, if it exists already */
|
|
model?: Maybe<Model>;
|
|
/** Alias for branchName */
|
|
modelName: Scalars['String']['output'];
|
|
/** Alias for streamId */
|
|
projectId: Scalars['String']['output'];
|
|
streamId: Scalars['String']['output'];
|
|
uploadComplete: Scalars['Boolean']['output'];
|
|
uploadDate: Scalars['DateTime']['output'];
|
|
/** The user's id that uploaded this file. */
|
|
userId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type GendoAiRender = {
|
|
__typename?: 'GendoAIRender';
|
|
camera?: Maybe<Scalars['JSONObject']['output']>;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
gendoGenerationId?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
modelId: Scalars['String']['output'];
|
|
projectId: Scalars['String']['output'];
|
|
prompt: Scalars['String']['output'];
|
|
/** This is a blob id. */
|
|
responseImage?: Maybe<Scalars['String']['output']>;
|
|
status: Scalars['String']['output'];
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
user?: Maybe<LimitedUser>;
|
|
userId: Scalars['String']['output'];
|
|
versionId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type GendoAiRenderCollection = {
|
|
__typename?: 'GendoAIRenderCollection';
|
|
items: Array<Maybe<GendoAiRender>>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type GendoAiRenderInput = {
|
|
/** Base64 encoded image of the depthmap. */
|
|
baseImage: Scalars['String']['input'];
|
|
camera: Scalars['JSONObject']['input'];
|
|
modelId: Scalars['ID']['input'];
|
|
projectId: Scalars['ID']['input'];
|
|
/** The generation prompt. */
|
|
prompt: Scalars['String']['input'];
|
|
versionId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type InvitableCollaboratorsFilter = {
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type JoinWorkspaceInput = {
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type LegacyCommentViewerData = {
|
|
__typename?: 'LegacyCommentViewerData';
|
|
/**
|
|
* An array representing a user's camera position:
|
|
* [camPos.x, camPos.y, camPos.z, camTarget.x, camTarget.y, camTarget.z, isOrtho, zoomNumber]
|
|
*/
|
|
camPos: Array<Scalars['Float']['output']>;
|
|
/** Old FE LocalFilterState type */
|
|
filters: CommentDataFilters;
|
|
/** THREE.Vector3 {x, y, z} */
|
|
location: Scalars['JSONObject']['output'];
|
|
/** Viewer.getCurrentSectionBox(): THREE.Box3 */
|
|
sectionBox?: Maybe<Scalars['JSONObject']['output']>;
|
|
/** Currently unused. Ideally comments should keep track of selected objects. */
|
|
selection?: Maybe<Scalars['JSONObject']['output']>;
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
activity?: Maybe<ActivityCollection>;
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
bio?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Get public stream commits authored by the user
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
commits?: Maybe<CommitCollection>;
|
|
company?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
name: Scalars['String']['output'];
|
|
role?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Returns all discoverable streams that the user is a collaborator on
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
streams: UserStreamCollection;
|
|
/**
|
|
* The user's timeline in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
timeline?: Maybe<ActivityCollection>;
|
|
/**
|
|
* Total amount of favorites attached to streams owned by the user
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
totalOwnedStreamsFavorites: Scalars['Int']['output'];
|
|
verified?: Maybe<Scalars['Boolean']['output']>;
|
|
workspaceDomainPolicyCompliant?: Maybe<Scalars['Boolean']['output']>;
|
|
workspaceRole?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']['input']>;
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserTimelineArgs = {
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserWorkspaceDomainPolicyCompliantArgs = {
|
|
workspaceSlug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
/**
|
|
* Limited user type, for showing public info about a user
|
|
* to another user
|
|
*/
|
|
export type LimitedUserWorkspaceRoleArgs = {
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
/** Workspace metadata visible to non-workspace members. */
|
|
export type LimitedWorkspace = {
|
|
__typename?: 'LimitedWorkspace';
|
|
/** Workspace description */
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
/** Workspace id */
|
|
id: Scalars['ID']['output'];
|
|
/** Optional base64 encoded workspace logo image */
|
|
logo?: Maybe<Scalars['String']['output']>;
|
|
/** Workspace name */
|
|
name: Scalars['String']['output'];
|
|
/** Unique workspace short id. Used for navigation. */
|
|
slug: Scalars['String']['output'];
|
|
/** Workspace members visible to people with verified email domain */
|
|
team?: Maybe<DiscoverableWorkspaceCollaboratorCollection>;
|
|
};
|
|
|
|
|
|
/** Workspace metadata visible to non-workspace members. */
|
|
export type LimitedWorkspaceTeamArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type LimitedWorkspaceJoinRequest = {
|
|
__typename?: 'LimitedWorkspaceJoinRequest';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['String']['output'];
|
|
status: WorkspaceJoinRequestStatus;
|
|
user: LimitedUser;
|
|
workspace: LimitedWorkspace;
|
|
};
|
|
|
|
export type LimitedWorkspaceJoinRequestCollection = {
|
|
__typename?: 'LimitedWorkspaceJoinRequestCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<LimitedWorkspaceJoinRequest>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type MarkCommentViewedInput = {
|
|
commentId: Scalars['String']['input'];
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type MarkReceivedVersionInput = {
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
projectId: Scalars['String']['input'];
|
|
sourceApplication: Scalars['String']['input'];
|
|
versionId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type Model = {
|
|
__typename?: 'Model';
|
|
author?: Maybe<LimitedUser>;
|
|
automationsStatus?: Maybe<TriggeredAutomationsStatus>;
|
|
/** Return a model tree of children */
|
|
childrenTree: Array<ModelsTreeItem>;
|
|
/** All comment threads in this model */
|
|
commentThreads: CommentCollection;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
/** The shortened/display name that doesn't include the names of parent models */
|
|
displayName: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
/** Full name including the names of parent models delimited by forward slashes */
|
|
name: Scalars['String']['output'];
|
|
/** Returns a list of versions that are being created from a file import */
|
|
pendingImportedVersions: Array<FileUpload>;
|
|
permissions: ModelPermissionChecks;
|
|
previewUrl?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
version: Version;
|
|
versions: VersionCollection;
|
|
};
|
|
|
|
|
|
export type ModelCommentThreadsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type ModelPendingImportedVersionsArgs = {
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type ModelVersionArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ModelVersionsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<ModelVersionsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type ModelCollection = {
|
|
__typename?: 'ModelCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Model>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type ModelMutations = {
|
|
__typename?: 'ModelMutations';
|
|
create: Model;
|
|
delete: Scalars['Boolean']['output'];
|
|
update: Model;
|
|
};
|
|
|
|
|
|
export type ModelMutationsCreateArgs = {
|
|
input: CreateModelInput;
|
|
};
|
|
|
|
|
|
export type ModelMutationsDeleteArgs = {
|
|
input: DeleteModelInput;
|
|
};
|
|
|
|
|
|
export type ModelMutationsUpdateArgs = {
|
|
input: UpdateModelInput;
|
|
};
|
|
|
|
export type ModelPermissionChecks = {
|
|
__typename?: 'ModelPermissionChecks';
|
|
canCreateVersion: PermissionCheckResult;
|
|
canDelete: PermissionCheckResult;
|
|
canUpdate: PermissionCheckResult;
|
|
};
|
|
|
|
export type ModelVersionsFilter = {
|
|
/** Make sure these specified versions are always loaded first */
|
|
priorityIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Only return versions specified in `priorityIds` */
|
|
priorityIdsOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
};
|
|
|
|
export type ModelsTreeItem = {
|
|
__typename?: 'ModelsTreeItem';
|
|
children: Array<ModelsTreeItem>;
|
|
fullName: Scalars['String']['output'];
|
|
/** Whether or not this item has nested children models */
|
|
hasChildren: Scalars['Boolean']['output'];
|
|
id: Scalars['ID']['output'];
|
|
/**
|
|
* Nullable cause the item can represent a parent that doesn't actually exist as a model on its own.
|
|
* E.g. A model named "foo/bar" is supposed to be a child of "foo" and will be represented as such,
|
|
* even if "foo" doesn't exist as its own model.
|
|
*/
|
|
model?: Maybe<Model>;
|
|
name: Scalars['String']['output'];
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
export type ModelsTreeItemCollection = {
|
|
__typename?: 'ModelsTreeItemCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<ModelsTreeItem>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type MoveVersionsInput = {
|
|
projectId: Scalars['ID']['input'];
|
|
/** If the name references a nonexistant model, it will be created */
|
|
targetModelName: Scalars['String']['input'];
|
|
versionIds: Array<Scalars['ID']['input']>;
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: 'Mutation';
|
|
/** The void stares back. */
|
|
_?: Maybe<Scalars['String']['output']>;
|
|
/** Various Active User oriented mutations */
|
|
activeUserMutations: ActiveUserMutations;
|
|
admin: AdminMutations;
|
|
adminDeleteUser: Scalars['Boolean']['output'];
|
|
/** Creates an personal api token. */
|
|
apiTokenCreate: Scalars['String']['output'];
|
|
/** Revokes (deletes) an personal api token/app token. */
|
|
apiTokenRevoke: Scalars['Boolean']['output'];
|
|
/** Register a new third party application. */
|
|
appCreate: Scalars['String']['output'];
|
|
/** Deletes a thirty party application. */
|
|
appDelete: Scalars['Boolean']['output'];
|
|
/** Revokes (de-authorizes) an application that you have previously authorized. */
|
|
appRevokeAccess?: Maybe<Scalars['Boolean']['output']>;
|
|
/** Create an app token. Only apps can create app tokens and they don't show up under personal access tokens. */
|
|
appTokenCreate: Scalars['String']['output'];
|
|
/** 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']['output'];
|
|
automateFunctionRunStatusReport: Scalars['Boolean']['output'];
|
|
automateMutations: AutomateMutations;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use ModelMutations.create instead. */
|
|
branchCreate: Scalars['String']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use ModelMutations.delete instead. */
|
|
branchDelete: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use ModelMutations.update instead. */
|
|
branchUpdate: Scalars['Boolean']['output'];
|
|
/** Broadcast user activity in the viewer */
|
|
broadcastViewerUserActivity: Scalars['Boolean']['output'];
|
|
/**
|
|
* Archives a comment.
|
|
* @deprecated Use commentMutations version
|
|
*/
|
|
commentArchive: Scalars['Boolean']['output'];
|
|
/**
|
|
* Creates a comment
|
|
* @deprecated Use commentMutations version
|
|
*/
|
|
commentCreate: Scalars['String']['output'];
|
|
/**
|
|
* Edits a comment.
|
|
* @deprecated Use commentMutations version
|
|
*/
|
|
commentEdit: Scalars['Boolean']['output'];
|
|
commentMutations: CommentMutations;
|
|
/**
|
|
* Adds a reply to a comment.
|
|
* @deprecated Use commentMutations version
|
|
*/
|
|
commentReply: Scalars['String']['output'];
|
|
/**
|
|
* Flags a comment as viewed by you (the logged in user).
|
|
* @deprecated Use commentMutations version
|
|
*/
|
|
commentView: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.create instead. */
|
|
commitCreate: Scalars['String']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.delete instead. */
|
|
commitDelete: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.markReceived instead. */
|
|
commitReceive: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.update/moveToModel instead. */
|
|
commitUpdate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Delete a batch of commits
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.delete instead.
|
|
*/
|
|
commitsDelete: Scalars['Boolean']['output'];
|
|
/**
|
|
* Move a batch of commits to a new branch
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use VersionMutations.moveToModel instead.
|
|
*/
|
|
commitsMove: Scalars['Boolean']['output'];
|
|
/**
|
|
* Delete a pending invite
|
|
* Note: The required scope to invoke this is not given out to app or personal access tokens
|
|
*/
|
|
inviteDelete: Scalars['Boolean']['output'];
|
|
/**
|
|
* Re-send a pending invite
|
|
* Note: The required scope to invoke this is not given out to app or personal access tokens
|
|
*/
|
|
inviteResend: Scalars['Boolean']['output'];
|
|
modelMutations: ModelMutations;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. */
|
|
objectCreate: Array<Scalars['String']['output']>;
|
|
projectMutations: ProjectMutations;
|
|
/** (Re-)send the account verification e-mail */
|
|
requestVerification: Scalars['Boolean']['output'];
|
|
requestVerificationByEmail: Scalars['Boolean']['output'];
|
|
serverInfoMutations: ServerInfoMutations;
|
|
serverInfoUpdate?: Maybe<Scalars['Boolean']['output']>;
|
|
/** Note: The required scope to invoke this is not given out to app or personal access tokens */
|
|
serverInviteBatchCreate: Scalars['Boolean']['output'];
|
|
/** Invite a new user to the speckle server and return the invite ID */
|
|
serverInviteCreate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Request access to a specific stream
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectAccessRequestMutations.create instead.
|
|
*/
|
|
streamAccessRequestCreate: StreamAccessRequest;
|
|
/**
|
|
* Accept or decline a stream access request. Must be a stream owner to invoke this.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectAccessRequestMutations.use instead.
|
|
*/
|
|
streamAccessRequestUse: Scalars['Boolean']['output'];
|
|
/**
|
|
* Creates a new stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.create instead.
|
|
*/
|
|
streamCreate?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Deletes an existing stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.delete instead.
|
|
*/
|
|
streamDelete: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. */
|
|
streamFavorite?: Maybe<Stream>;
|
|
/**
|
|
* Note: The required scope to invoke this is not given out to app or personal access tokens
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectInviteMutations.batchCreate instead.
|
|
*/
|
|
streamInviteBatchCreate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Cancel a pending stream invite. Can only be invoked by a stream owner.
|
|
* Note: The required scope to invoke this is not given out to app or personal access tokens
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectInviteMutations.cancel instead.
|
|
*/
|
|
streamInviteCancel: Scalars['Boolean']['output'];
|
|
/**
|
|
* Invite a new or registered user to the specified stream
|
|
* Note: The required scope to invoke this is not given out to app or personal access tokens
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectInviteMutations.create instead.
|
|
*/
|
|
streamInviteCreate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Accept or decline a stream invite
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectInviteMutations.use instead.
|
|
*/
|
|
streamInviteUse: Scalars['Boolean']['output'];
|
|
/**
|
|
* Remove yourself from stream collaborators (not possible for the owner)
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.leave instead.
|
|
*/
|
|
streamLeave: Scalars['Boolean']['output'];
|
|
/**
|
|
* Revokes the permissions of a user on a given stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.updateRole instead.
|
|
*/
|
|
streamRevokePermission?: Maybe<Scalars['Boolean']['output']>;
|
|
/**
|
|
* Updates an existing stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.update instead.
|
|
*/
|
|
streamUpdate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Update permissions of a user on a given stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.updateRole instead.
|
|
*/
|
|
streamUpdatePermission?: Maybe<Scalars['Boolean']['output']>;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use ProjectMutations.batchDelete instead. */
|
|
streamsDelete: Scalars['Boolean']['output'];
|
|
/**
|
|
* Used for broadcasting real time typing status in comment threads. Does not persist any info.
|
|
* @deprecated Use broadcastViewerUserActivity
|
|
*/
|
|
userCommentThreadActivityBroadcast: Scalars['Boolean']['output'];
|
|
/** Delete a user's account. */
|
|
userDelete: Scalars['Boolean']['output'];
|
|
userNotificationPreferencesUpdate?: Maybe<Scalars['Boolean']['output']>;
|
|
userRoleChange: Scalars['Boolean']['output'];
|
|
/**
|
|
* Edits a user's profile.
|
|
* @deprecated Use activeUserMutations version
|
|
*/
|
|
userUpdate: Scalars['Boolean']['output'];
|
|
/**
|
|
* Used for broadcasting real time chat head bubbles and status. Does not persist any info.
|
|
* @deprecated Use broadcastViewerUserActivity
|
|
*/
|
|
userViewerActivityBroadcast: Scalars['Boolean']['output'];
|
|
versionMutations: VersionMutations;
|
|
/** Creates a new webhook on a stream */
|
|
webhookCreate: Scalars['String']['output'];
|
|
/** Deletes an existing webhook */
|
|
webhookDelete: Scalars['String']['output'];
|
|
/** Updates an existing webhook */
|
|
webhookUpdate: Scalars['String']['output'];
|
|
workspaceJoinRequestMutations: WorkspaceJoinRequestMutations;
|
|
workspaceMutations: WorkspaceMutations;
|
|
};
|
|
|
|
|
|
export type MutationAdminDeleteUserArgs = {
|
|
userConfirmation: UserDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationApiTokenCreateArgs = {
|
|
token: ApiTokenCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationApiTokenRevokeArgs = {
|
|
token: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationAppCreateArgs = {
|
|
app: AppCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationAppDeleteArgs = {
|
|
appId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationAppRevokeAccessArgs = {
|
|
appId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationAppTokenCreateArgs = {
|
|
token: AppTokenCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationAppUpdateArgs = {
|
|
app: AppUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationAutomateFunctionRunStatusReportArgs = {
|
|
input: AutomateFunctionRunStatusReportInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchCreateArgs = {
|
|
branch: BranchCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchDeleteArgs = {
|
|
branch: BranchDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationBranchUpdateArgs = {
|
|
branch: BranchUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationBroadcastViewerUserActivityArgs = {
|
|
message: ViewerUserActivityMessageInput;
|
|
projectId: Scalars['String']['input'];
|
|
resourceIdString: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationCommentArchiveArgs = {
|
|
archived?: Scalars['Boolean']['input'];
|
|
commentId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationCommentCreateArgs = {
|
|
input: CommentCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentEditArgs = {
|
|
input: CommentEditInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentReplyArgs = {
|
|
input: ReplyCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationCommentViewArgs = {
|
|
commentId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
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']['input'];
|
|
};
|
|
|
|
|
|
export type MutationInviteResendArgs = {
|
|
inviteId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationObjectCreateArgs = {
|
|
objectInput: ObjectCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationRequestVerificationByEmailArgs = {
|
|
email: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationServerInfoUpdateArgs = {
|
|
info: ServerInfoUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationServerInviteBatchCreateArgs = {
|
|
input: Array<ServerInviteCreateInput>;
|
|
};
|
|
|
|
|
|
export type MutationServerInviteCreateArgs = {
|
|
input: ServerInviteCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamAccessRequestCreateArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamAccessRequestUseArgs = {
|
|
accept: Scalars['Boolean']['input'];
|
|
requestId: Scalars['String']['input'];
|
|
role?: StreamRole;
|
|
};
|
|
|
|
|
|
export type MutationStreamCreateArgs = {
|
|
stream: StreamCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamDeleteArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamFavoriteArgs = {
|
|
favorited: Scalars['Boolean']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteBatchCreateArgs = {
|
|
input: Array<StreamInviteCreateInput>;
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteCancelArgs = {
|
|
inviteId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteCreateArgs = {
|
|
input: StreamInviteCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamInviteUseArgs = {
|
|
accept: Scalars['Boolean']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
token: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamLeaveArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationStreamRevokePermissionArgs = {
|
|
permissionParams: StreamRevokePermissionInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamUpdateArgs = {
|
|
stream: StreamUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamUpdatePermissionArgs = {
|
|
permissionParams: StreamUpdatePermissionInput;
|
|
};
|
|
|
|
|
|
export type MutationStreamsDeleteArgs = {
|
|
ids?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
|
|
export type MutationUserCommentThreadActivityBroadcastArgs = {
|
|
commentId: Scalars['String']['input'];
|
|
data?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationUserDeleteArgs = {
|
|
userConfirmation: UserDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationUserNotificationPreferencesUpdateArgs = {
|
|
preferences: Scalars['JSONObject']['input'];
|
|
};
|
|
|
|
|
|
export type MutationUserRoleChangeArgs = {
|
|
userRoleInput: UserRoleInput;
|
|
};
|
|
|
|
|
|
export type MutationUserUpdateArgs = {
|
|
user: UserUpdateInput;
|
|
};
|
|
|
|
|
|
export type MutationUserViewerActivityBroadcastArgs = {
|
|
data?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
resourceId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type MutationWebhookCreateArgs = {
|
|
webhook: WebhookCreateInput;
|
|
};
|
|
|
|
|
|
export type MutationWebhookDeleteArgs = {
|
|
webhook: WebhookDeleteInput;
|
|
};
|
|
|
|
|
|
export type MutationWebhookUpdateArgs = {
|
|
webhook: WebhookUpdateInput;
|
|
};
|
|
|
|
export type Object = {
|
|
__typename?: 'Object';
|
|
/** @deprecated Not implemented. */
|
|
applicationId?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* 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"}] ){
|
|
* ...
|
|
* }
|
|
* ```
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
commentCount: Scalars['Int']['output'];
|
|
createdAt?: Maybe<Scalars['DateTime']['output']>;
|
|
/** 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']['output']>;
|
|
id: Scalars['String']['output'];
|
|
speckleType?: Maybe<Scalars['String']['output']>;
|
|
totalChildrenCount?: Maybe<Scalars['Int']['output']>;
|
|
};
|
|
|
|
|
|
export type ObjectChildrenArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
depth?: Scalars['Int']['input'];
|
|
limit?: Scalars['Int']['input'];
|
|
orderBy?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
query?: InputMaybe<Array<Scalars['JSONObject']['input']>>;
|
|
select?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
};
|
|
|
|
export type ObjectCollection = {
|
|
__typename?: 'ObjectCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
objects: Array<Object>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type ObjectCreateInput = {
|
|
/** The objects you want to create. */
|
|
objects: Array<InputMaybe<Scalars['JSONObject']['input']>>;
|
|
/** The stream against which these objects will be created. */
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type OnboardingCompletionInput = {
|
|
plans?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
source?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export enum PaidWorkspacePlans {
|
|
Pro = 'pro',
|
|
ProUnlimited = 'proUnlimited',
|
|
Team = 'team',
|
|
TeamUnlimited = 'teamUnlimited'
|
|
}
|
|
|
|
export type PasswordStrengthCheckFeedback = {
|
|
__typename?: 'PasswordStrengthCheckFeedback';
|
|
suggestions: Array<Scalars['String']['output']>;
|
|
warning?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
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']['output'];
|
|
};
|
|
|
|
export type PendingStreamCollaborator = {
|
|
__typename?: 'PendingStreamCollaborator';
|
|
id: Scalars['String']['output'];
|
|
inviteId: Scalars['String']['output'];
|
|
invitedBy: LimitedUser;
|
|
projectId: Scalars['String']['output'];
|
|
projectName: Scalars['String']['output'];
|
|
role: Scalars['String']['output'];
|
|
/** @deprecated Use projectId instead */
|
|
streamId: Scalars['String']['output'];
|
|
/** @deprecated Use projectName instead */
|
|
streamName: Scalars['String']['output'];
|
|
/** E-mail address or name of the invited user */
|
|
title: Scalars['String']['output'];
|
|
/** Only available if the active user is the pending stream collaborator */
|
|
token?: Maybe<Scalars['String']['output']>;
|
|
/** Set only if user is registered */
|
|
user?: Maybe<LimitedUser>;
|
|
};
|
|
|
|
export type PendingWorkspaceCollaborator = {
|
|
__typename?: 'PendingWorkspaceCollaborator';
|
|
/**
|
|
* E-mail address if target is unregistered or primary e-mail of target registered user
|
|
* if token was specified to retrieve this invite
|
|
*/
|
|
email?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
inviteId: Scalars['String']['output'];
|
|
invitedBy: LimitedUser;
|
|
/** Target workspace role */
|
|
role: Scalars['String']['output'];
|
|
/** E-mail address or name of the invited user */
|
|
title: Scalars['String']['output'];
|
|
/**
|
|
* Only available if the active user is the pending workspace collaborator or if it was already
|
|
* specified when retrieving this invite
|
|
*/
|
|
token?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
/** Set only if user is registered */
|
|
user?: Maybe<LimitedUser>;
|
|
workspaceId: Scalars['String']['output'];
|
|
workspaceName: Scalars['String']['output'];
|
|
workspaceSlug: Scalars['String']['output'];
|
|
};
|
|
|
|
export type PendingWorkspaceCollaboratorsFilter = {
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type PermissionCheckResult = {
|
|
__typename?: 'PermissionCheckResult';
|
|
authorized: Scalars['Boolean']['output'];
|
|
code: Scalars['String']['output'];
|
|
message: Scalars['String']['output'];
|
|
payload?: Maybe<Scalars['JSONObject']['output']>;
|
|
};
|
|
|
|
export type Price = {
|
|
__typename?: 'Price';
|
|
amount: Scalars['Float']['output'];
|
|
currency: Scalars['String']['output'];
|
|
currencySymbol: Scalars['String']['output'];
|
|
};
|
|
|
|
export type Project = {
|
|
__typename?: 'Project';
|
|
allowPublicComments: Scalars['Boolean']['output'];
|
|
/** Get a single automation by id. Error will be thrown if automation is not found or inaccessible. */
|
|
automation: Automation;
|
|
automations: AutomationCollection;
|
|
blob?: Maybe<BlobMetadata>;
|
|
/** Get the metadata collection of blobs stored for this stream. */
|
|
blobs?: Maybe<BlobMetadataCollection>;
|
|
/** Get specific project comment/thread by ID */
|
|
comment?: Maybe<Comment>;
|
|
/** All comment threads in this project */
|
|
commentThreads: ProjectCommentCollection;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
invitableCollaborators: WorkspaceCollaboratorCollection;
|
|
/** Collaborators who have been invited, but not yet accepted. */
|
|
invitedTeam?: Maybe<Array<PendingStreamCollaborator>>;
|
|
/** Returns a specific model by its ID */
|
|
model: Model;
|
|
/** Retrieve a specific project model by its ID */
|
|
modelByName: Model;
|
|
/** Return a model tree of children for the specified model name */
|
|
modelChildrenTree: Array<ModelsTreeItem>;
|
|
/** Returns a flat list of all models */
|
|
models: ModelCollection;
|
|
/**
|
|
* Return's a project's models in a tree view with submodels being nested under parent models
|
|
* real or fake (e.g., with a foo/bar model, it will be nested under foo even if such a model doesn't actually exist)
|
|
*/
|
|
modelsTree: ModelsTreeItemCollection;
|
|
/** Returns information about the potential effects of moving a project to a given workspace. */
|
|
moveToWorkspaceDryRun: ProjectMoveToWorkspaceDryRun;
|
|
name: Scalars['String']['output'];
|
|
object?: Maybe<Object>;
|
|
/** Pending project access requests */
|
|
pendingAccessRequests?: Maybe<Array<ProjectAccessRequest>>;
|
|
/** Returns a list models that are being created from a file import */
|
|
pendingImportedModels: Array<FileUpload>;
|
|
permissions: ProjectPermissionChecks;
|
|
/** Active user's role for this project. `null` if request is not authenticated, or the project is not explicitly shared with you. */
|
|
role?: Maybe<Scalars['String']['output']>;
|
|
/** Source apps used in any models of this project */
|
|
sourceApps: Array<Scalars['String']['output']>;
|
|
team: Array<ProjectCollaborator>;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
/** Retrieve a specific project version by its ID */
|
|
version: Version;
|
|
/** Returns a flat list of all project versions */
|
|
versions: VersionCollection;
|
|
/** Return metadata about resources being requested in the viewer */
|
|
viewerResources: Array<ViewerResourceGroup>;
|
|
visibility: SimpleProjectVisibility;
|
|
webhooks: WebhookCollection;
|
|
workspace?: Maybe<Workspace>;
|
|
workspaceId?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
|
|
export type ProjectAutomationArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectAutomationsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type ProjectBlobArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectBlobsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type ProjectCommentArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectCommentThreadsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<ProjectCommentsFilter>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type ProjectInvitableCollaboratorsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<InvitableCollaboratorsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectModelArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectModelByNameArgs = {
|
|
name: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectModelChildrenTreeArgs = {
|
|
fullName: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectModelsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<ProjectModelsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectModelsTreeArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<ProjectModelsTreeFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectMoveToWorkspaceDryRunArgs = {
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectObjectArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectPendingImportedModelsArgs = {
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type ProjectVersionArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectVersionsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectViewerResourcesArgs = {
|
|
loadedVersionsOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
resourceIdString: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectWebhooksArgs = {
|
|
id?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
/** Created when a user requests to become a contributor on a project */
|
|
export type ProjectAccessRequest = {
|
|
__typename?: 'ProjectAccessRequest';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['ID']['output'];
|
|
/** Can only be selected if authed user has proper access */
|
|
project: Project;
|
|
projectId: Scalars['String']['output'];
|
|
requester: LimitedUser;
|
|
requesterId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ProjectAccessRequestMutations = {
|
|
__typename?: 'ProjectAccessRequestMutations';
|
|
/** Request access to a specific project */
|
|
create: ProjectAccessRequest;
|
|
/** Accept or decline a project access request. Must be a project owner to invoke this. */
|
|
use: Project;
|
|
};
|
|
|
|
|
|
export type ProjectAccessRequestMutationsCreateArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectAccessRequestMutationsUseArgs = {
|
|
accept: Scalars['Boolean']['input'];
|
|
requestId: Scalars['String']['input'];
|
|
role?: StreamRole;
|
|
};
|
|
|
|
export type ProjectAutomationCreateInput = {
|
|
enabled: Scalars['Boolean']['input'];
|
|
name: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ProjectAutomationMutations = {
|
|
__typename?: 'ProjectAutomationMutations';
|
|
create: Automation;
|
|
createRevision: AutomationRevision;
|
|
createTestAutomation: Automation;
|
|
createTestAutomationRun: TestAutomationRun;
|
|
delete: Scalars['Boolean']['output'];
|
|
/**
|
|
* Trigger an automation with a fake "version created" trigger. The "version created" will
|
|
* just refer to the last version of the model.
|
|
*/
|
|
trigger: Scalars['String']['output'];
|
|
update: Automation;
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsCreateArgs = {
|
|
input: ProjectAutomationCreateInput;
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsCreateRevisionArgs = {
|
|
input: ProjectAutomationRevisionCreateInput;
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsCreateTestAutomationArgs = {
|
|
input: ProjectTestAutomationCreateInput;
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsCreateTestAutomationRunArgs = {
|
|
automationId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsDeleteArgs = {
|
|
automationId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsTriggerArgs = {
|
|
automationId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectAutomationMutationsUpdateArgs = {
|
|
input: ProjectAutomationUpdateInput;
|
|
};
|
|
|
|
export type ProjectAutomationRevisionCreateInput = {
|
|
automationId: Scalars['ID']['input'];
|
|
functions: Array<AutomationRevisionCreateFunctionInput>;
|
|
/** AutomateTypes.TriggerDefinitionsSchema type from @speckle/shared */
|
|
triggerDefinitions: Scalars['JSONObject']['input'];
|
|
};
|
|
|
|
export type ProjectAutomationUpdateInput = {
|
|
enabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ProjectAutomationsUpdatedMessage = {
|
|
__typename?: 'ProjectAutomationsUpdatedMessage';
|
|
automation?: Maybe<Automation>;
|
|
automationId: Scalars['String']['output'];
|
|
/** Only set if type === CREATED_REVISION */
|
|
revision?: Maybe<AutomationRevision>;
|
|
type: ProjectAutomationsUpdatedMessageType;
|
|
};
|
|
|
|
export enum ProjectAutomationsUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
CreatedRevision = 'CREATED_REVISION',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectCollaborator = {
|
|
__typename?: 'ProjectCollaborator';
|
|
id: Scalars['ID']['output'];
|
|
role: Scalars['String']['output'];
|
|
/** The collaborator's workspace seat type for the workspace this project is in */
|
|
seatType?: Maybe<WorkspaceSeatType>;
|
|
user: LimitedUser;
|
|
/** The collaborator's workspace role for the workspace this project is in, if any */
|
|
workspaceRole?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
export type ProjectCollection = {
|
|
__typename?: 'ProjectCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Project>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type ProjectCommentCollection = {
|
|
__typename?: 'ProjectCommentCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Comment>;
|
|
totalArchivedCount: Scalars['Int']['output'];
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type ProjectCommentsFilter = {
|
|
/** Whether or not to include archived/resolved threads */
|
|
includeArchived?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/**
|
|
* By default if resourceIdString is set, the "versionId" part of model resource identifiers will be ignored
|
|
* and all comments of all versions of any of the referenced models will be returned. If `loadedVersionsOnly` is
|
|
* enabled, then only comment threads of loaded/referenced versions in resourceIdString will be returned.
|
|
*/
|
|
loadedVersionsOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/**
|
|
* Only request comments belonging to the resources identified by this
|
|
* comma-delimited resouce string (same format that's used in the viewer URL)
|
|
*/
|
|
resourceIdString?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ProjectCommentsUpdatedMessage = {
|
|
__typename?: 'ProjectCommentsUpdatedMessage';
|
|
/** Null if deleted */
|
|
comment?: Maybe<Comment>;
|
|
id: Scalars['String']['output'];
|
|
type: ProjectCommentsUpdatedMessageType;
|
|
};
|
|
|
|
export enum ProjectCommentsUpdatedMessageType {
|
|
Archived = 'ARCHIVED',
|
|
Created = 'CREATED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
/** Any values left null will be ignored */
|
|
export type ProjectCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
visibility?: InputMaybe<ProjectVisibility>;
|
|
};
|
|
|
|
export type ProjectFileImportUpdatedMessage = {
|
|
__typename?: 'ProjectFileImportUpdatedMessage';
|
|
/** Upload ID */
|
|
id: Scalars['String']['output'];
|
|
type: ProjectFileImportUpdatedMessageType;
|
|
upload: FileUpload;
|
|
};
|
|
|
|
export enum ProjectFileImportUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectInviteCreateInput = {
|
|
/** Either this or userId must be filled */
|
|
email?: InputMaybe<Scalars['String']['input']>;
|
|
/** Defaults to the contributor role, if not specified */
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
/** Can only be specified if guest mode is on or if the user is an admin */
|
|
serverRole?: InputMaybe<Scalars['String']['input']>;
|
|
/** Either this or email must be filled */
|
|
userId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ProjectInviteMutations = {
|
|
__typename?: 'ProjectInviteMutations';
|
|
/** Batch invite to project */
|
|
batchCreate: Project;
|
|
/** Cancel a pending stream invite. Can only be invoked by a project owner. */
|
|
cancel: Project;
|
|
/** Invite a new or registered user to be a project collaborator. Can only be invoked by a project owner. */
|
|
create: Project;
|
|
/**
|
|
* Create invite(-s) for a project in a workspace. Unlike the base create() mutation, this allows
|
|
* configuring the workspace role.
|
|
*/
|
|
createForWorkspace: Project;
|
|
/** Accept or decline a project invite */
|
|
use: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type ProjectInviteMutationsBatchCreateArgs = {
|
|
input: Array<ProjectInviteCreateInput>;
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectInviteMutationsCancelArgs = {
|
|
inviteId: Scalars['String']['input'];
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectInviteMutationsCreateArgs = {
|
|
input: ProjectInviteCreateInput;
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectInviteMutationsCreateForWorkspaceArgs = {
|
|
inputs: Array<WorkspaceProjectInviteCreateInput>;
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectInviteMutationsUseArgs = {
|
|
input: ProjectInviteUseInput;
|
|
};
|
|
|
|
export type ProjectInviteUseInput = {
|
|
accept: Scalars['Boolean']['input'];
|
|
projectId: Scalars['ID']['input'];
|
|
token: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ProjectModelsFilter = {
|
|
/** Filter by IDs of contributors who participated in models */
|
|
contributors?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Excldue models w/ the specified IDs */
|
|
excludeIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Only select models w/ the specified IDs */
|
|
ids?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Filter out models that don't have any versions */
|
|
onlyWithVersions?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Filter by model names */
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
/** Filter by source apps used in models */
|
|
sourceApps?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type ProjectModelsTreeFilter = {
|
|
/** Filter by IDs of contributors who participated in models */
|
|
contributors?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Search for specific models. If used, tree items from different levels may be mixed. */
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
/** Filter by source apps used in models */
|
|
sourceApps?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type ProjectModelsUpdatedMessage = {
|
|
__typename?: 'ProjectModelsUpdatedMessage';
|
|
/** Model ID */
|
|
id: Scalars['String']['output'];
|
|
/** Null if model was deleted */
|
|
model?: Maybe<Model>;
|
|
type: ProjectModelsUpdatedMessageType;
|
|
};
|
|
|
|
export enum ProjectModelsUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
Deleted = 'DELETED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectMoveToWorkspaceDryRun = {
|
|
__typename?: 'ProjectMoveToWorkspaceDryRun';
|
|
addedToWorkspace: Array<LimitedUser>;
|
|
addedToWorkspaceTotalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
|
|
export type ProjectMoveToWorkspaceDryRunAddedToWorkspaceArgs = {
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type ProjectMutations = {
|
|
__typename?: 'ProjectMutations';
|
|
/** Access request related mutations */
|
|
accessRequestMutations: ProjectAccessRequestMutations;
|
|
automationMutations: ProjectAutomationMutations;
|
|
/** Batch delete projects */
|
|
batchDelete: Scalars['Boolean']['output'];
|
|
/** Create new project */
|
|
create: Project;
|
|
/**
|
|
* Create onboarding/tutorial project. If one is already created for the active user, that
|
|
* one will be returned instead.
|
|
*/
|
|
createForOnboarding: Project;
|
|
/** Delete an existing project */
|
|
delete: Scalars['Boolean']['output'];
|
|
/** Invite related mutations */
|
|
invites: ProjectInviteMutations;
|
|
/** Leave a project. Only possible if you're not the last remaining owner. */
|
|
leave: Scalars['Boolean']['output'];
|
|
/** Updates an existing project */
|
|
update: Project;
|
|
/** Update role for a collaborator */
|
|
updateRole: Project;
|
|
};
|
|
|
|
|
|
export type ProjectMutationsAutomationMutationsArgs = {
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectMutationsBatchDeleteArgs = {
|
|
ids: Array<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type ProjectMutationsCreateArgs = {
|
|
input?: InputMaybe<ProjectCreateInput>;
|
|
};
|
|
|
|
|
|
export type ProjectMutationsDeleteArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectMutationsLeaveArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type ProjectMutationsUpdateArgs = {
|
|
update: ProjectUpdateInput;
|
|
};
|
|
|
|
|
|
export type ProjectMutationsUpdateRoleArgs = {
|
|
input: ProjectUpdateRoleInput;
|
|
};
|
|
|
|
export type ProjectPendingModelsUpdatedMessage = {
|
|
__typename?: 'ProjectPendingModelsUpdatedMessage';
|
|
/** Upload ID */
|
|
id: Scalars['String']['output'];
|
|
model: FileUpload;
|
|
type: ProjectPendingModelsUpdatedMessageType;
|
|
};
|
|
|
|
export enum ProjectPendingModelsUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectPendingVersionsUpdatedMessage = {
|
|
__typename?: 'ProjectPendingVersionsUpdatedMessage';
|
|
/** Upload ID */
|
|
id: Scalars['String']['output'];
|
|
type: ProjectPendingVersionsUpdatedMessageType;
|
|
version: FileUpload;
|
|
};
|
|
|
|
export enum ProjectPendingVersionsUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectPermissionChecks = {
|
|
__typename?: 'ProjectPermissionChecks';
|
|
canBroadcastActivity: PermissionCheckResult;
|
|
canCreateAutomation: PermissionCheckResult;
|
|
canCreateComment: PermissionCheckResult;
|
|
canCreateModel: PermissionCheckResult;
|
|
canDelete: PermissionCheckResult;
|
|
canLeave: PermissionCheckResult;
|
|
canMoveToWorkspace: PermissionCheckResult;
|
|
canRead: PermissionCheckResult;
|
|
canReadSettings: PermissionCheckResult;
|
|
canReadWebhooks: PermissionCheckResult;
|
|
canRequestRender: PermissionCheckResult;
|
|
canUpdate: PermissionCheckResult;
|
|
canUpdateAllowPublicComments: PermissionCheckResult;
|
|
};
|
|
|
|
|
|
export type ProjectPermissionChecksCanMoveToWorkspaceArgs = {
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ProjectRole = {
|
|
__typename?: 'ProjectRole';
|
|
project: Project;
|
|
role: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ProjectTestAutomationCreateInput = {
|
|
functionId: Scalars['String']['input'];
|
|
modelId: Scalars['String']['input'];
|
|
name: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ProjectTriggeredAutomationsStatusUpdatedMessage = {
|
|
__typename?: 'ProjectTriggeredAutomationsStatusUpdatedMessage';
|
|
model: Model;
|
|
project: Project;
|
|
run: AutomateRun;
|
|
type: ProjectTriggeredAutomationsStatusUpdatedMessageType;
|
|
version: Version;
|
|
};
|
|
|
|
export enum ProjectTriggeredAutomationsStatusUpdatedMessageType {
|
|
RunCreated = 'RUN_CREATED',
|
|
RunUpdated = 'RUN_UPDATED'
|
|
}
|
|
|
|
/** Any values left null will be ignored, so only set the properties that you want updated */
|
|
export type ProjectUpdateInput = {
|
|
allowPublicComments?: InputMaybe<Scalars['Boolean']['input']>;
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
visibility?: InputMaybe<ProjectVisibility>;
|
|
};
|
|
|
|
export type ProjectUpdateRoleInput = {
|
|
projectId: Scalars['String']['input'];
|
|
/** Leave role as null to revoke access entirely */
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
userId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ProjectUpdatedMessage = {
|
|
__typename?: 'ProjectUpdatedMessage';
|
|
/** Project ID */
|
|
id: Scalars['String']['output'];
|
|
/** Project entity, null if project was deleted */
|
|
project?: Maybe<Project>;
|
|
/** Message type */
|
|
type: ProjectUpdatedMessageType;
|
|
};
|
|
|
|
export enum ProjectUpdatedMessageType {
|
|
Deleted = 'DELETED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export type ProjectVersionsPreviewGeneratedMessage = {
|
|
__typename?: 'ProjectVersionsPreviewGeneratedMessage';
|
|
objectId: Scalars['String']['output'];
|
|
projectId: Scalars['String']['output'];
|
|
versionId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ProjectVersionsUpdatedMessage = {
|
|
__typename?: 'ProjectVersionsUpdatedMessage';
|
|
/** Version ID */
|
|
id: Scalars['String']['output'];
|
|
/** Version's model ID */
|
|
modelId: Scalars['String']['output'];
|
|
type: ProjectVersionsUpdatedMessageType;
|
|
/** Null if version was deleted */
|
|
version?: Maybe<Version>;
|
|
};
|
|
|
|
export enum ProjectVersionsUpdatedMessageType {
|
|
Created = 'CREATED',
|
|
Deleted = 'DELETED',
|
|
Updated = 'UPDATED'
|
|
}
|
|
|
|
export enum ProjectVisibility {
|
|
Private = 'PRIVATE',
|
|
Public = 'PUBLIC',
|
|
Unlisted = 'UNLISTED'
|
|
}
|
|
|
|
export type Query = {
|
|
__typename?: 'Query';
|
|
/** Stare into the void. */
|
|
_?: Maybe<Scalars['String']['output']>;
|
|
/** Gets the profile of the authenticated user or null if not authenticated */
|
|
activeUser?: Maybe<User>;
|
|
admin: AdminQueries;
|
|
/**
|
|
* All the streams of the server. Available to admins only.
|
|
* @deprecated use admin.projectList instead
|
|
*/
|
|
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.
|
|
* @deprecated use admin.UserList instead
|
|
*/
|
|
adminUsers?: Maybe<AdminUsersListCollection>;
|
|
/** Gets a specific app from the server. */
|
|
app?: Maybe<ServerApp>;
|
|
/**
|
|
* Returns all the publicly available apps on this server.
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
apps?: Maybe<Array<Maybe<ServerAppListItem>>>;
|
|
/** If user is authenticated using an app token, this will describe the app */
|
|
authenticatedAsApp?: Maybe<ServerAppListItem>;
|
|
/** Get a single automate function by id. Error will be thrown if function is not found or inaccessible. */
|
|
automateFunction: AutomateFunction;
|
|
automateFunctions: AutomateFunctionCollection;
|
|
/** Part of the automation/function creation handshake mechanism */
|
|
automateValidateAuthCode: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.comment instead. */
|
|
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.**
|
|
* @deprecated Use Project/Version/Model 'commentThreads' fields instead
|
|
*/
|
|
comments?: Maybe<CommentCollection>;
|
|
/**
|
|
* All of the discoverable streams of the server
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
discoverableStreams?: Maybe<StreamCollection>;
|
|
/** Get the (limited) profile information of another server user */
|
|
otherUser?: Maybe<LimitedUser>;
|
|
/**
|
|
* Find a specific project. Will throw an authorization error if active user isn't authorized
|
|
* to see it, for example, if a project isn't public and the user doesn't have the appropriate rights.
|
|
*/
|
|
project: Project;
|
|
/**
|
|
* Look for an invitation to a project, for the current user (authed or not). If token
|
|
* isn't specified, the server will look for any valid invite.
|
|
*/
|
|
projectInvite?: Maybe<PendingStreamCollaborator>;
|
|
serverInfo: ServerInfo;
|
|
/** Receive metadata about an invite by the invite token */
|
|
serverInviteByToken?: Maybe<ServerInvite>;
|
|
/** @deprecated use admin.serverStatistics instead */
|
|
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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Query.project instead.
|
|
*/
|
|
stream?: Maybe<Stream>;
|
|
/**
|
|
* Get authed user's stream access request
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use User.projectAccessRequest instead.
|
|
*/
|
|
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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Query.projectInvite instead.
|
|
*/
|
|
streamInvite?: Maybe<PendingStreamCollaborator>;
|
|
/**
|
|
* Get all invitations to streams that the active user has
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use User.projectInvites instead.
|
|
*/
|
|
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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use User.projects instead.
|
|
*/
|
|
streams?: Maybe<UserStreamCollection>;
|
|
/**
|
|
* 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
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
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
|
|
* @deprecated Use users() instead.
|
|
*/
|
|
userSearch: UserSearchResultCollection;
|
|
/** Look up server users */
|
|
users: UserSearchResultCollection;
|
|
/** Look up server users with a collection of emails */
|
|
usersByEmail: Array<Maybe<LimitedUser>>;
|
|
/** Validates the slug, to make sure it contains only valid characters and its not taken. */
|
|
validateWorkspaceSlug: Scalars['Boolean']['output'];
|
|
workspace: Workspace;
|
|
workspaceBySlug: Workspace;
|
|
/**
|
|
* Look for an invitation to a workspace, for the current user (authed or not).
|
|
*
|
|
* If token is specified, it will return the corresponding invite even if it belongs to a different user.
|
|
*
|
|
* Either token or workspaceId must be specified, or both
|
|
*/
|
|
workspaceInvite?: Maybe<PendingWorkspaceCollaborator>;
|
|
/** Find workspaces a given user email can use SSO to sign with */
|
|
workspaceSsoByEmail: Array<LimitedWorkspace>;
|
|
};
|
|
|
|
|
|
export type QueryAdminStreamsArgs = {
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
offset?: InputMaybe<Scalars['Int']['input']>;
|
|
orderBy?: InputMaybe<Scalars['String']['input']>;
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
visibility?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryAdminUsersArgs = {
|
|
limit?: Scalars['Int']['input'];
|
|
offset?: Scalars['Int']['input'];
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryAppArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryAutomateFunctionArgs = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type QueryAutomateFunctionsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<AutomateFunctionsFilter>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryAutomateValidateAuthCodeArgs = {
|
|
payload: AutomateAuthCodePayloadTest;
|
|
resources?: InputMaybe<AutomateAuthCodeResources>;
|
|
};
|
|
|
|
|
|
export type QueryCommentArgs = {
|
|
id: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryCommentsArgs = {
|
|
archived?: Scalars['Boolean']['input'];
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
resources?: InputMaybe<Array<InputMaybe<ResourceIdentifierInput>>>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryDiscoverableStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
sort?: InputMaybe<DiscoverableStreamsSortingInput>;
|
|
};
|
|
|
|
|
|
export type QueryOtherUserArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryProjectArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryProjectInviteArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
token?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryServerInviteByTokenArgs = {
|
|
token?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryStreamArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryStreamAccessRequestArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryStreamInviteArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
token?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryStreamsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryUserArgs = {
|
|
id?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryUserPwdStrengthArgs = {
|
|
pwd: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryUserSearchArgs = {
|
|
archived?: InputMaybe<Scalars['Boolean']['input']>;
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
emailOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
query: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryUsersArgs = {
|
|
input: UsersRetrievalInput;
|
|
};
|
|
|
|
|
|
export type QueryUsersByEmailArgs = {
|
|
input: BulkUsersRetrievalInput;
|
|
};
|
|
|
|
|
|
export type QueryValidateWorkspaceSlugArgs = {
|
|
slug: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryWorkspaceArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryWorkspaceBySlugArgs = {
|
|
slug: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type QueryWorkspaceInviteArgs = {
|
|
options?: InputMaybe<WorkspaceInviteLookupOptions>;
|
|
token?: InputMaybe<Scalars['String']['input']>;
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type QueryWorkspaceSsoByEmailArgs = {
|
|
email: Scalars['String']['input'];
|
|
};
|
|
|
|
/** Deprecated: Used by old stream-based mutations */
|
|
export type ReplyCreateInput = {
|
|
/** IDs of uploaded blobs that should be attached to this reply */
|
|
blobIds: Array<Scalars['String']['input']>;
|
|
data?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
parentComment: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
/** ProseMirror document object */
|
|
text?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
};
|
|
|
|
export type ResourceIdentifier = {
|
|
__typename?: 'ResourceIdentifier';
|
|
resourceId: Scalars['String']['output'];
|
|
resourceType: ResourceType;
|
|
};
|
|
|
|
export type ResourceIdentifierInput = {
|
|
resourceId: Scalars['String']['input'];
|
|
resourceType: ResourceType;
|
|
};
|
|
|
|
export enum ResourceType {
|
|
Comment = 'comment',
|
|
Commit = 'commit',
|
|
Object = 'object',
|
|
Stream = 'stream'
|
|
}
|
|
|
|
export type Role = {
|
|
__typename?: 'Role';
|
|
description: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
resourceTarget: Scalars['String']['output'];
|
|
};
|
|
|
|
export type RootPermissionChecks = {
|
|
__typename?: 'RootPermissionChecks';
|
|
canCreatePersonalProject: PermissionCheckResult;
|
|
};
|
|
|
|
/** Available scopes. */
|
|
export type Scope = {
|
|
__typename?: 'Scope';
|
|
description: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ServerApp = {
|
|
__typename?: 'ServerApp';
|
|
author?: Maybe<AppAuthor>;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
logo?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
public?: Maybe<Scalars['Boolean']['output']>;
|
|
redirectUrl: Scalars['String']['output'];
|
|
scopes: Array<Scope>;
|
|
secret?: Maybe<Scalars['String']['output']>;
|
|
termsAndConditionsLink?: Maybe<Scalars['String']['output']>;
|
|
trustByDefault?: Maybe<Scalars['Boolean']['output']>;
|
|
};
|
|
|
|
export type ServerAppListItem = {
|
|
__typename?: 'ServerAppListItem';
|
|
author?: Maybe<AppAuthor>;
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
logo?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
redirectUrl: Scalars['String']['output'];
|
|
termsAndConditionsLink?: Maybe<Scalars['String']['output']>;
|
|
trustByDefault?: Maybe<Scalars['Boolean']['output']>;
|
|
};
|
|
|
|
export type ServerAutomateInfo = {
|
|
__typename?: 'ServerAutomateInfo';
|
|
availableFunctionTemplates: Array<AutomateFunctionTemplate>;
|
|
};
|
|
|
|
/** Server configuration. */
|
|
export type ServerConfiguration = {
|
|
__typename?: 'ServerConfiguration';
|
|
blobSizeLimitBytes: Scalars['Int']['output'];
|
|
/** Whether the email feature is enabled on this server */
|
|
isEmailEnabled: Scalars['Boolean']['output'];
|
|
objectMultipartUploadSizeLimitBytes: Scalars['Int']['output'];
|
|
objectSizeLimitBytes: Scalars['Int']['output'];
|
|
};
|
|
|
|
/** Information about this server. */
|
|
export type ServerInfo = {
|
|
__typename?: 'ServerInfo';
|
|
adminContact?: Maybe<Scalars['String']['output']>;
|
|
/** The authentication strategies available on this server. */
|
|
authStrategies: Array<AuthStrategy>;
|
|
automate: ServerAutomateInfo;
|
|
/** Base URL of Speckle Automate, if set */
|
|
automateUrl?: Maybe<Scalars['String']['output']>;
|
|
/** @deprecated Use the ServerInfo{configuration{blobSizeLimitBytes}} field instead. */
|
|
blobSizeLimitBytes: Scalars['Int']['output'];
|
|
canonicalUrl?: Maybe<Scalars['String']['output']>;
|
|
company?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Configuration values that are specific to this server.
|
|
* These are read-only and can only be adjusted during server setup.
|
|
* Please contact your server administrator if you wish to suggest a change to these values.
|
|
*/
|
|
configuration: ServerConfiguration;
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
/** Whether or not to show messaging about FE2 (banners etc.) */
|
|
enableNewWebUiMessaging?: Maybe<Scalars['Boolean']['output']>;
|
|
guestModeEnabled: Scalars['Boolean']['output'];
|
|
inviteOnly?: Maybe<Scalars['Boolean']['output']>;
|
|
/** Server relocation / migration info */
|
|
migration?: Maybe<ServerMigration>;
|
|
/** Info about server regions */
|
|
multiRegion: ServerMultiRegionConfiguration;
|
|
name: Scalars['String']['output'];
|
|
/** @deprecated Use role constants from the @speckle/shared npm package instead */
|
|
roles: Array<Role>;
|
|
scopes: Array<Scope>;
|
|
serverRoles: Array<ServerRoleItem>;
|
|
termsOfService?: Maybe<Scalars['String']['output']>;
|
|
version?: Maybe<Scalars['String']['output']>;
|
|
workspaces: ServerWorkspacesInfo;
|
|
};
|
|
|
|
export type ServerInfoMutations = {
|
|
__typename?: 'ServerInfoMutations';
|
|
multiRegion: ServerRegionMutations;
|
|
};
|
|
|
|
export type ServerInfoUpdateInput = {
|
|
adminContact?: InputMaybe<Scalars['String']['input']>;
|
|
company?: InputMaybe<Scalars['String']['input']>;
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
guestModeEnabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
inviteOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
name: Scalars['String']['input'];
|
|
termsOfService?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ServerInvite = {
|
|
__typename?: 'ServerInvite';
|
|
email: Scalars['String']['output'];
|
|
id: Scalars['String']['output'];
|
|
invitedBy: LimitedUser;
|
|
};
|
|
|
|
export type ServerInviteCreateInput = {
|
|
email: Scalars['String']['input'];
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
/** Can only be specified if guest mode is on or if the user is an admin */
|
|
serverRole?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type ServerMigration = {
|
|
__typename?: 'ServerMigration';
|
|
movedFrom?: Maybe<Scalars['String']['output']>;
|
|
movedTo?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
export type ServerMultiRegionConfiguration = {
|
|
__typename?: 'ServerMultiRegionConfiguration';
|
|
/**
|
|
* Keys of available regions defined in the multi region config file. Used keys will
|
|
* be filtered out from the result.
|
|
*/
|
|
availableKeys: Array<Scalars['String']['output']>;
|
|
/** Regions available for project data residency */
|
|
regions: Array<ServerRegionItem>;
|
|
};
|
|
|
|
export type ServerRegionItem = {
|
|
__typename?: 'ServerRegionItem';
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
key: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ServerRegionMutations = {
|
|
__typename?: 'ServerRegionMutations';
|
|
create: ServerRegionItem;
|
|
update: ServerRegionItem;
|
|
};
|
|
|
|
|
|
export type ServerRegionMutationsCreateArgs = {
|
|
input: CreateServerRegionInput;
|
|
};
|
|
|
|
|
|
export type ServerRegionMutationsUpdateArgs = {
|
|
input: UpdateServerRegionInput;
|
|
};
|
|
|
|
export enum ServerRole {
|
|
ServerAdmin = 'SERVER_ADMIN',
|
|
ServerArchivedUser = 'SERVER_ARCHIVED_USER',
|
|
ServerGuest = 'SERVER_GUEST',
|
|
ServerUser = 'SERVER_USER'
|
|
}
|
|
|
|
export type ServerRoleItem = {
|
|
__typename?: 'ServerRoleItem';
|
|
id: Scalars['String']['output'];
|
|
title: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ServerStatistics = {
|
|
__typename?: 'ServerStatistics';
|
|
totalPendingInvites: Scalars['Int']['output'];
|
|
totalProjectCount: Scalars['Int']['output'];
|
|
totalUserCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type ServerStats = {
|
|
__typename?: 'ServerStats';
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
commitHistory?: Maybe<Array<Maybe<Scalars['JSONObject']['output']>>>;
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
objectHistory?: Maybe<Array<Maybe<Scalars['JSONObject']['output']>>>;
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
streamHistory?: Maybe<Array<Maybe<Scalars['JSONObject']['output']>>>;
|
|
totalCommitCount: Scalars['Int']['output'];
|
|
totalObjectCount: Scalars['Int']['output'];
|
|
totalStreamCount: Scalars['Int']['output'];
|
|
totalUserCount: Scalars['Int']['output'];
|
|
/** An array of objects currently structured as { created_month: Date, count: int }. */
|
|
userHistory?: Maybe<Array<Maybe<Scalars['JSONObject']['output']>>>;
|
|
};
|
|
|
|
export type ServerWorkspacesInfo = {
|
|
__typename?: 'ServerWorkspacesInfo';
|
|
/** Up-to-date prices for paid & non-invoiced Workspace plans */
|
|
planPrices?: Maybe<CurrencyBasedPrices>;
|
|
/**
|
|
* This is a backend control variable for the workspaces feature set.
|
|
* Since workspaces need a backend logic to be enabled, this is not enough as a feature flag.
|
|
*/
|
|
workspacesEnabled: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export enum SessionPaymentStatus {
|
|
Paid = 'paid',
|
|
Unpaid = 'unpaid'
|
|
}
|
|
|
|
export type SetPrimaryUserEmailInput = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
/** Visibility without the "discoverable" option */
|
|
export enum SimpleProjectVisibility {
|
|
Private = 'PRIVATE',
|
|
Unlisted = 'UNLISTED'
|
|
}
|
|
|
|
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']['output']>;
|
|
/** The type of editor value (comment, blog post etc.) */
|
|
type: Scalars['String']['output'];
|
|
/** The version of the schema */
|
|
version: Scalars['String']['output'];
|
|
};
|
|
|
|
export enum SortDirection {
|
|
Asc = 'ASC',
|
|
Desc = 'DESC'
|
|
}
|
|
|
|
export type Stream = {
|
|
__typename?: 'Stream';
|
|
/**
|
|
* All the recent activity on this stream in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
activity?: Maybe<ActivityCollection>;
|
|
allowPublicComments: Scalars['Boolean']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.blob instead. */
|
|
blob?: Maybe<BlobMetadata>;
|
|
/**
|
|
* Get the metadata collection of blobs stored for this stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Project.blobs instead.
|
|
*/
|
|
blobs?: Maybe<BlobMetadataCollection>;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.model or Project.modelByName instead. */
|
|
branch?: Maybe<Branch>;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.models or Project.modelsTree instead. */
|
|
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"){
|
|
* ...
|
|
* }
|
|
* ```
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
commentCount: Scalars['Int']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.version instead. */
|
|
commit?: Maybe<Commit>;
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.versions instead. */
|
|
commits?: Maybe<CommitCollection>;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
/** 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']['output']>;
|
|
favoritesCount: Scalars['Int']['output'];
|
|
/**
|
|
* Returns a specific file upload that belongs to this stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Project.pendingImportedModels or Model.pendingImportedVersions instead.
|
|
*/
|
|
fileUpload?: Maybe<FileUpload>;
|
|
/**
|
|
* Returns a list of all the file uploads for this stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Project.pendingImportedModels or Model.pendingImportedVersions instead.
|
|
*/
|
|
fileUploads: Array<FileUpload>;
|
|
id: Scalars['String']['output'];
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable: Scalars['Boolean']['output'];
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic: Scalars['Boolean']['output'];
|
|
name: Scalars['String']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.object instead. */
|
|
object?: Maybe<Object>;
|
|
/**
|
|
* Pending stream access requests
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use Project.pendingAccessRequests instead.
|
|
*/
|
|
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']['output']>;
|
|
size?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
/** @deprecated Part of the old API surface and will be removed in the future. Use Project.webhooks instead. */
|
|
webhooks: WebhookCollection;
|
|
};
|
|
|
|
|
|
export type StreamActivityArgs = {
|
|
actionType?: InputMaybe<Scalars['String']['input']>;
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type StreamBlobArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type StreamBlobsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
query?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type StreamBranchArgs = {
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type StreamBranchesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type StreamCommitArgs = {
|
|
id?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type StreamCommitsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type StreamFileUploadArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type StreamObjectArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type StreamWebhooksArgs = {
|
|
id?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
/** Created when a user requests to become a contributor on a stream */
|
|
export type StreamAccessRequest = {
|
|
__typename?: 'StreamAccessRequest';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['ID']['output'];
|
|
requester: LimitedUser;
|
|
requesterId: Scalars['String']['output'];
|
|
/** Can only be selected if authed user has proper access */
|
|
stream: Stream;
|
|
streamId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type StreamCollaborator = {
|
|
__typename?: 'StreamCollaborator';
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
company?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
role: Scalars['String']['output'];
|
|
serverRole: Scalars['String']['output'];
|
|
};
|
|
|
|
export type StreamCollection = {
|
|
__typename?: 'StreamCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items?: Maybe<Array<Stream>>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type StreamCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic?: InputMaybe<Scalars['Boolean']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
/** Optionally specify user IDs of users that you want to invite to be contributors to this stream */
|
|
withContributors?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type StreamInviteCreateInput = {
|
|
email?: InputMaybe<Scalars['String']['input']>;
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
/** Defaults to the contributor role, if not specified */
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
/** Can only be specified if guest mode is on or if the user is an admin */
|
|
serverRole?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
userId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type StreamRevokePermissionInput = {
|
|
streamId: Scalars['String']['input'];
|
|
userId: Scalars['String']['input'];
|
|
};
|
|
|
|
export enum StreamRole {
|
|
StreamContributor = 'STREAM_CONTRIBUTOR',
|
|
StreamOwner = 'STREAM_OWNER',
|
|
StreamReviewer = 'STREAM_REVIEWER'
|
|
}
|
|
|
|
export type StreamUpdateInput = {
|
|
allowPublicComments?: InputMaybe<Scalars['Boolean']['input']>;
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['String']['input'];
|
|
/**
|
|
* Whether the stream (if public) can be found on public stream exploration pages
|
|
* and searches
|
|
*/
|
|
isDiscoverable?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Whether the stream can be viewed by non-contributors */
|
|
isPublic?: InputMaybe<Scalars['Boolean']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type StreamUpdatePermissionInput = {
|
|
role: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
userId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type Subscription = {
|
|
__typename?: 'Subscription';
|
|
/** It's lonely in the void. */
|
|
_?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Subscribe to branch created event
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectModelsUpdated' instead.
|
|
*/
|
|
branchCreated?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Subscribe to branch deleted event
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectModelsUpdated' instead.
|
|
*/
|
|
branchDeleted?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Subscribe to branch updated event.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectModelsUpdated' instead.
|
|
*/
|
|
branchUpdated?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* 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.
|
|
* @deprecated Use projectCommentsUpdated
|
|
*/
|
|
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.
|
|
* @deprecated Use projectCommentsUpdated or viewerUserActivityBroadcasted for reply status
|
|
*/
|
|
commentThreadActivity: CommentThreadActivityMessage;
|
|
/**
|
|
* Subscribe to commit created event
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectVersionsUpdated' instead.
|
|
*/
|
|
commitCreated?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Subscribe to commit deleted event
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectVersionsUpdated' instead.
|
|
*/
|
|
commitDeleted?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Subscribe to commit updated event.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use 'projectVersionsUpdated' instead.
|
|
*/
|
|
commitUpdated?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Cyclically sends a message to the client, used for testing
|
|
* Note: Only works in test environment
|
|
*/
|
|
ping: Scalars['String']['output'];
|
|
/** Subscribe to updates to automations in the project */
|
|
projectAutomationsUpdated: ProjectAutomationsUpdatedMessage;
|
|
/**
|
|
* Subscribe to updates to resource comments/threads. Optionally specify resource ID string to only receive
|
|
* updates regarding comments for those resources.
|
|
*/
|
|
projectCommentsUpdated: ProjectCommentsUpdatedMessage;
|
|
/**
|
|
* Subscribe to changes to any of a project's file imports
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use projectPendingModelsUpdated or projectPendingVersionsUpdated instead.
|
|
*/
|
|
projectFileImportUpdated: ProjectFileImportUpdatedMessage;
|
|
/** Subscribe to changes to a project's models. Optionally specify modelIds to track. */
|
|
projectModelsUpdated: ProjectModelsUpdatedMessage;
|
|
/** Subscribe to changes to a project's pending models */
|
|
projectPendingModelsUpdated: ProjectPendingModelsUpdatedMessage;
|
|
/** Subscribe to changes to a project's pending versions */
|
|
projectPendingVersionsUpdated: ProjectPendingVersionsUpdatedMessage;
|
|
/** Subscribe to updates to any triggered automations statuses in the project */
|
|
projectTriggeredAutomationsStatusUpdated: ProjectTriggeredAutomationsStatusUpdatedMessage;
|
|
/** Track updates to a specific project */
|
|
projectUpdated: ProjectUpdatedMessage;
|
|
projectVersionGendoAIRenderCreated: GendoAiRender;
|
|
projectVersionGendoAIRenderUpdated: GendoAiRender;
|
|
/** Subscribe to when a project's versions get their preview image fully generated. */
|
|
projectVersionsPreviewGenerated: ProjectVersionsPreviewGeneratedMessage;
|
|
/** Subscribe to changes to a project's versions. */
|
|
projectVersionsUpdated: ProjectVersionsUpdatedMessage;
|
|
/**
|
|
* Subscribes to stream deleted event. Use this in clients/components that pertain only to this stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use projectUpdated instead.
|
|
*/
|
|
streamDeleted?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Subscribes to stream updated event. Use this in clients/components that pertain only to this stream.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use projectUpdated instead.
|
|
*/
|
|
streamUpdated?: Maybe<Scalars['JSONObject']['output']>;
|
|
/** Track newly added or deleted projects owned by the active user */
|
|
userProjectsUpdated: UserProjectsUpdatedMessage;
|
|
/**
|
|
* 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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use userProjectsUpdated instead.
|
|
*/
|
|
userStreamAdded?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* 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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use userProjectsUpdated instead.
|
|
*/
|
|
userStreamRemoved?: Maybe<Scalars['JSONObject']['output']>;
|
|
/**
|
|
* Broadcasts "real-time" location data for viewer users.
|
|
* @deprecated Use viewerUserActivityBroadcasted
|
|
*/
|
|
userViewerActivity?: Maybe<Scalars['JSONObject']['output']>;
|
|
/** Track user activities in the viewer relating to the specified resources */
|
|
viewerUserActivityBroadcasted: ViewerUserActivityMessage;
|
|
/**
|
|
* Track newly added or deleted projects in a specific workspace.
|
|
* Either slug or id must be set.
|
|
*/
|
|
workspaceProjectsUpdated: WorkspaceProjectsUpdatedMessage;
|
|
/**
|
|
* Track updates to a specific workspace.
|
|
* Either slug or id must be set.
|
|
*/
|
|
workspaceUpdated: WorkspaceUpdatedMessage;
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchCreatedArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchDeletedArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionBranchUpdatedArgs = {
|
|
branchId?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommentActivityArgs = {
|
|
resourceIds?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommentThreadActivityArgs = {
|
|
commentId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitCreatedArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitDeletedArgs = {
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionCommitUpdatedArgs = {
|
|
commitId?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectAutomationsUpdatedArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectCommentsUpdatedArgs = {
|
|
target: ViewerUpdateTrackingTarget;
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectFileImportUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectModelsUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
modelIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectPendingModelsUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectPendingVersionsUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectTriggeredAutomationsStatusUpdatedArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectVersionGendoAiRenderCreatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
versionId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectVersionGendoAiRenderUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
versionId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectVersionsPreviewGeneratedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionProjectVersionsUpdatedArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionStreamDeletedArgs = {
|
|
streamId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionStreamUpdatedArgs = {
|
|
streamId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionUserViewerActivityArgs = {
|
|
resourceId: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type SubscriptionViewerUserActivityBroadcastedArgs = {
|
|
sessionId?: InputMaybe<Scalars['String']['input']>;
|
|
target: ViewerUpdateTrackingTarget;
|
|
};
|
|
|
|
|
|
export type SubscriptionWorkspaceProjectsUpdatedArgs = {
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
workspaceSlug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
|
|
export type SubscriptionWorkspaceUpdatedArgs = {
|
|
workspaceId?: InputMaybe<Scalars['String']['input']>;
|
|
workspaceSlug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type TestAutomationRun = {
|
|
__typename?: 'TestAutomationRun';
|
|
automationRunId: Scalars['String']['output'];
|
|
functionRunId: Scalars['String']['output'];
|
|
triggers: Array<TestAutomationRunTrigger>;
|
|
};
|
|
|
|
export type TestAutomationRunTrigger = {
|
|
__typename?: 'TestAutomationRunTrigger';
|
|
payload: TestAutomationRunTriggerPayload;
|
|
triggerType: Scalars['String']['output'];
|
|
};
|
|
|
|
export type TestAutomationRunTriggerPayload = {
|
|
__typename?: 'TestAutomationRunTriggerPayload';
|
|
modelId: Scalars['String']['output'];
|
|
versionId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type TokenResourceIdentifier = {
|
|
__typename?: 'TokenResourceIdentifier';
|
|
id: Scalars['String']['output'];
|
|
type: TokenResourceIdentifierType;
|
|
};
|
|
|
|
export type TokenResourceIdentifierInput = {
|
|
id: Scalars['String']['input'];
|
|
type: TokenResourceIdentifierType;
|
|
};
|
|
|
|
export enum TokenResourceIdentifierType {
|
|
Project = 'project',
|
|
Workspace = 'workspace'
|
|
}
|
|
|
|
export type TriggeredAutomationsStatus = {
|
|
__typename?: 'TriggeredAutomationsStatus';
|
|
automationRuns: Array<AutomateRun>;
|
|
id: Scalars['ID']['output'];
|
|
status: AutomateRunStatus;
|
|
statusMessage?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
/** Any null values will be ignored */
|
|
export type UpdateAutomateFunctionInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
/** SourceAppNames values from @speckle/shared */
|
|
supportedSourceApps?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
tags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
workspaceIds?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type UpdateModelInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
id: Scalars['ID']['input'];
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
projectId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type UpdateServerRegionInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
key: Scalars['String']['input'];
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
/** Only non-null values will be updated */
|
|
export type UpdateVersionInput = {
|
|
message?: InputMaybe<Scalars['String']['input']>;
|
|
projectId: Scalars['ID']['input'];
|
|
versionId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type UpgradePlanInput = {
|
|
billingInterval: BillingInterval;
|
|
workspaceId: Scalars['ID']['input'];
|
|
workspacePlan: PaidWorkspacePlans;
|
|
};
|
|
|
|
/**
|
|
* 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';
|
|
/** The last-visited workspace for the given user */
|
|
activeWorkspace?: Maybe<Workspace>;
|
|
/**
|
|
* All the recent activity from this user in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
activity?: Maybe<ActivityCollection>;
|
|
/** Returns a list of your personal api tokens. */
|
|
apiTokens: Array<ApiToken>;
|
|
/** Returns the apps you have authorized. */
|
|
authorizedApps?: Maybe<Array<ServerAppListItem>>;
|
|
automateFunctions: AutomateFunctionCollection;
|
|
automateInfo: UserAutomateInfo;
|
|
avatar?: Maybe<Scalars['String']['output']>;
|
|
bio?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* Get commits authored by the user. If requested for another user, then only commits
|
|
* from public streams will be returned.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use User.versions instead.
|
|
*/
|
|
commits?: Maybe<CommitCollection>;
|
|
company?: Maybe<Scalars['String']['output']>;
|
|
/** Returns the apps you have created. */
|
|
createdApps?: Maybe<Array<ServerApp>>;
|
|
createdAt?: Maybe<Scalars['DateTime']['output']>;
|
|
/** Get discoverable workspaces with verified domains that match the active user's */
|
|
discoverableWorkspaces: Array<LimitedWorkspace>;
|
|
/** Only returned if API user is the user being requested or an admin */
|
|
email?: Maybe<Scalars['String']['output']>;
|
|
emails: Array<UserEmail>;
|
|
/**
|
|
* A list of workspaces for the active user where:
|
|
* (1) The user is a member or admin
|
|
* (2) The workspace has SSO provider enabled
|
|
* (3) The user does not have a valid SSO session for the given SSO provider
|
|
*/
|
|
expiredSsoSessions: Array<LimitedWorkspace>;
|
|
/**
|
|
* All the streams that a active user has favorited.
|
|
* Note: You can't use this to retrieve another user's favorite streams.
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
favoriteStreams: StreamCollection;
|
|
gendoAICredits: UserGendoAiCredits;
|
|
/** Whether the user has a pending/active email verification token */
|
|
hasPendingVerification?: Maybe<Scalars['Boolean']['output']>;
|
|
id: Scalars['ID']['output'];
|
|
/** Whether post-sign up onboarding has been finished or skipped entirely */
|
|
isOnboardingFinished?: Maybe<Scalars['Boolean']['output']>;
|
|
/** Returns `true` if last visited project was "legacy" "personal project" outside of a workspace */
|
|
isProjectsActive?: Maybe<Scalars['Boolean']['output']>;
|
|
meta: UserMeta;
|
|
name: Scalars['String']['output'];
|
|
notificationPreferences: Scalars['JSONObject']['output'];
|
|
permissions: RootPermissionChecks;
|
|
profiles?: Maybe<Scalars['JSONObject']['output']>;
|
|
/** Get pending project access request, that the user made */
|
|
projectAccessRequest?: Maybe<ProjectAccessRequest>;
|
|
/** Get all invitations to projects that the active user has */
|
|
projectInvites: Array<PendingStreamCollaborator>;
|
|
/** Get projects that the user participates in */
|
|
projects: UserProjectCollection;
|
|
role?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* 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.
|
|
* @deprecated Part of the old API surface and will be removed in the future. Use User.projects instead.
|
|
*/
|
|
streams: UserStreamCollection;
|
|
/**
|
|
* The user's timeline in chronological order
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
timeline?: Maybe<ActivityCollection>;
|
|
/**
|
|
* Total amount of favorites attached to streams owned by the user
|
|
* @deprecated Part of the old API surface and will be removed in the future.
|
|
*/
|
|
totalOwnedStreamsFavorites: Scalars['Int']['output'];
|
|
verified?: Maybe<Scalars['Boolean']['output']>;
|
|
/**
|
|
* Get (count of) user's versions. By default gets all versions of all projects the user has access to.
|
|
* Set authoredOnly=true to only retrieve versions authored by the user.
|
|
*
|
|
* Note: Only count resolution is currently implemented
|
|
*/
|
|
versions: CountOnlyCollection;
|
|
/** Get all invitations to workspaces that the active user has */
|
|
workspaceInvites: Array<PendingWorkspaceCollaborator>;
|
|
workspaceJoinRequests?: Maybe<LimitedWorkspaceJoinRequestCollection>;
|
|
/** Get the workspaces for the user */
|
|
workspaces: WorkspaceCollection;
|
|
};
|
|
|
|
|
|
/**
|
|
* 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']['input']>;
|
|
after?: InputMaybe<Scalars['DateTime']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserAutomateFunctionsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<AutomateFunctionsFilter>;
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
|
|
/**
|
|
* 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']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserProjectAccessRequestArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserProjectsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<UserProjectsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
sortBy?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
|
|
/**
|
|
* 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']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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']['input']>;
|
|
before?: InputMaybe<Scalars['DateTime']['input']>;
|
|
cursor?: InputMaybe<Scalars['DateTime']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserVersionsArgs = {
|
|
authoredOnly?: Scalars['Boolean']['input'];
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserWorkspaceJoinRequestsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<WorkspaceJoinRequestFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
/**
|
|
* 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 UserWorkspacesArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<UserWorkspacesFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type UserAutomateInfo = {
|
|
__typename?: 'UserAutomateInfo';
|
|
availableGithubOrgs: Array<Scalars['String']['output']>;
|
|
hasAutomateGithubApp: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type UserDeleteInput = {
|
|
email: Scalars['String']['input'];
|
|
};
|
|
|
|
export type UserEmail = {
|
|
__typename?: 'UserEmail';
|
|
email: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
primary: Scalars['Boolean']['output'];
|
|
userId: Scalars['ID']['output'];
|
|
verified: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type UserEmailMutations = {
|
|
__typename?: 'UserEmailMutations';
|
|
create: User;
|
|
delete: User;
|
|
requestNewEmailVerification?: Maybe<Scalars['Boolean']['output']>;
|
|
setPrimary: User;
|
|
verify?: Maybe<Scalars['Boolean']['output']>;
|
|
};
|
|
|
|
|
|
export type UserEmailMutationsCreateArgs = {
|
|
input: CreateUserEmailInput;
|
|
};
|
|
|
|
|
|
export type UserEmailMutationsDeleteArgs = {
|
|
input: DeleteUserEmailInput;
|
|
};
|
|
|
|
|
|
export type UserEmailMutationsRequestNewEmailVerificationArgs = {
|
|
input: EmailVerificationRequestInput;
|
|
};
|
|
|
|
|
|
export type UserEmailMutationsSetPrimaryArgs = {
|
|
input: SetPrimaryUserEmailInput;
|
|
};
|
|
|
|
|
|
export type UserEmailMutationsVerifyArgs = {
|
|
input: VerifyUserEmailInput;
|
|
};
|
|
|
|
export type UserGendoAiCredits = {
|
|
__typename?: 'UserGendoAICredits';
|
|
limit: Scalars['Int']['output'];
|
|
resetDate: Scalars['DateTime']['output'];
|
|
used: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type UserMeta = {
|
|
__typename?: 'UserMeta';
|
|
legacyProjectsExplainerCollapsed: Scalars['Boolean']['output'];
|
|
newWorkspaceExplainerDismissed: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
export type UserMetaMutations = {
|
|
__typename?: 'UserMetaMutations';
|
|
setLegacyProjectsExplainerCollapsed: Scalars['Boolean']['output'];
|
|
setNewWorkspaceExplainerDismissed: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type UserMetaMutationsSetLegacyProjectsExplainerCollapsedArgs = {
|
|
value: Scalars['Boolean']['input'];
|
|
};
|
|
|
|
|
|
export type UserMetaMutationsSetNewWorkspaceExplainerDismissedArgs = {
|
|
value: Scalars['Boolean']['input'];
|
|
};
|
|
|
|
export type UserProjectCollection = {
|
|
__typename?: 'UserProjectCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Project>;
|
|
numberOfHidden: Scalars['Int']['output'];
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type UserProjectsFilter = {
|
|
/**
|
|
* If set to true, will also include streams that the user may not have an explicit role on,
|
|
* but has implicit access to because of workspaces
|
|
*/
|
|
includeImplicitAccess?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Only include projects where user has the specified roles */
|
|
onlyWithRoles?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Only include personal projects (not in any workspace) */
|
|
personalOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Filter out projects by name */
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
/** Only include projects in the specified workspace */
|
|
workspaceId?: InputMaybe<Scalars['ID']['input']>;
|
|
};
|
|
|
|
export type UserProjectsUpdatedMessage = {
|
|
__typename?: 'UserProjectsUpdatedMessage';
|
|
/** Project ID */
|
|
id: Scalars['String']['output'];
|
|
/** Project entity, null if project was deleted */
|
|
project?: Maybe<Project>;
|
|
/** Message type */
|
|
type: UserProjectsUpdatedMessageType;
|
|
};
|
|
|
|
export enum UserProjectsUpdatedMessageType {
|
|
Added = 'ADDED',
|
|
Removed = 'REMOVED'
|
|
}
|
|
|
|
export type UserRoleInput = {
|
|
id: Scalars['String']['input'];
|
|
role: Scalars['String']['input'];
|
|
};
|
|
|
|
export type UserSearchResultCollection = {
|
|
__typename?: 'UserSearchResultCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<LimitedUser>;
|
|
};
|
|
|
|
export type UserStreamCollection = {
|
|
__typename?: 'UserStreamCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items?: Maybe<Array<Stream>>;
|
|
numberOfHidden: Scalars['Int']['output'];
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type UserUpdateInput = {
|
|
avatar?: InputMaybe<Scalars['String']['input']>;
|
|
bio?: InputMaybe<Scalars['String']['input']>;
|
|
company?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type UserWorkspacesFilter = {
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type UsersRetrievalInput = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
/** Only find users with directly matching emails */
|
|
emailOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
/** Limit defaults to 10 */
|
|
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
/** Only find users that are collaborators of the specified project */
|
|
projectId?: InputMaybe<Scalars['String']['input']>;
|
|
/** The query looks for matches in user name & email */
|
|
query: Scalars['String']['input'];
|
|
};
|
|
|
|
export type VerifyUserEmailInput = {
|
|
code: Scalars['String']['input'];
|
|
email: Scalars['String']['input'];
|
|
};
|
|
|
|
export type Version = {
|
|
__typename?: 'Version';
|
|
authorUser?: Maybe<LimitedUser>;
|
|
automationsStatus?: Maybe<TriggeredAutomationsStatus>;
|
|
/** All comment threads in this version */
|
|
commentThreads: CommentCollection;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
gendoAIRender: GendoAiRender;
|
|
gendoAIRenders: GendoAiRenderCollection;
|
|
id: Scalars['ID']['output'];
|
|
message?: Maybe<Scalars['String']['output']>;
|
|
model: Model;
|
|
parents?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
|
|
permissions: VersionPermissionChecks;
|
|
previewUrl: Scalars['String']['output'];
|
|
referencedObject?: Maybe<Scalars['String']['output']>;
|
|
sourceApplication?: Maybe<Scalars['String']['output']>;
|
|
totalChildrenCount?: Maybe<Scalars['Int']['output']>;
|
|
};
|
|
|
|
|
|
export type VersionCommentThreadsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type VersionGendoAiRenderArgs = {
|
|
id: Scalars['String']['input'];
|
|
};
|
|
|
|
export type VersionCollection = {
|
|
__typename?: 'VersionCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Version>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type VersionCreatedTrigger = {
|
|
__typename?: 'VersionCreatedTrigger';
|
|
model?: Maybe<Model>;
|
|
type: AutomateRunTriggerType;
|
|
version?: Maybe<Version>;
|
|
};
|
|
|
|
export type VersionCreatedTriggerDefinition = {
|
|
__typename?: 'VersionCreatedTriggerDefinition';
|
|
model?: Maybe<Model>;
|
|
type: AutomateRunTriggerType;
|
|
};
|
|
|
|
export type VersionMutations = {
|
|
__typename?: 'VersionMutations';
|
|
create: Version;
|
|
delete: Scalars['Boolean']['output'];
|
|
markReceived: Scalars['Boolean']['output'];
|
|
moveToModel: Model;
|
|
requestGendoAIRender: Scalars['Boolean']['output'];
|
|
update: Version;
|
|
};
|
|
|
|
|
|
export type VersionMutationsCreateArgs = {
|
|
input: CreateVersionInput;
|
|
};
|
|
|
|
|
|
export type VersionMutationsDeleteArgs = {
|
|
input: DeleteVersionsInput;
|
|
};
|
|
|
|
|
|
export type VersionMutationsMarkReceivedArgs = {
|
|
input: MarkReceivedVersionInput;
|
|
};
|
|
|
|
|
|
export type VersionMutationsMoveToModelArgs = {
|
|
input: MoveVersionsInput;
|
|
};
|
|
|
|
|
|
export type VersionMutationsRequestGendoAiRenderArgs = {
|
|
input: GendoAiRenderInput;
|
|
};
|
|
|
|
|
|
export type VersionMutationsUpdateArgs = {
|
|
input: UpdateVersionInput;
|
|
};
|
|
|
|
export type VersionPermissionChecks = {
|
|
__typename?: 'VersionPermissionChecks';
|
|
canReceive: PermissionCheckResult;
|
|
canUpdate: PermissionCheckResult;
|
|
};
|
|
|
|
export type ViewerResourceGroup = {
|
|
__typename?: 'ViewerResourceGroup';
|
|
/** Resource identifier used to refer to a collection of resource items */
|
|
identifier: Scalars['String']['output'];
|
|
/** Viewer resources that the identifier refers to */
|
|
items: Array<ViewerResourceItem>;
|
|
};
|
|
|
|
export type ViewerResourceItem = {
|
|
__typename?: 'ViewerResourceItem';
|
|
/** Null if resource represents an object */
|
|
modelId?: Maybe<Scalars['String']['output']>;
|
|
objectId: Scalars['String']['output'];
|
|
/** Null if resource represents an object */
|
|
versionId?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
export type ViewerUpdateTrackingTarget = {
|
|
/**
|
|
* By default if resourceIdString is set, the "versionId" part of model resource identifiers will be ignored
|
|
* and all updates to of all versions of any of the referenced models will be returned. If `loadedVersionsOnly` is
|
|
* enabled, then only updates of loaded/referenced versions in resourceIdString will be returned.
|
|
*/
|
|
loadedVersionsOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
projectId: Scalars['String']['input'];
|
|
/**
|
|
* Only request updates to the resources identified by this
|
|
* comma-delimited resouce string (same format that's used in the viewer URL)
|
|
*/
|
|
resourceIdString: Scalars['String']['input'];
|
|
};
|
|
|
|
export type ViewerUserActivityMessage = {
|
|
__typename?: 'ViewerUserActivityMessage';
|
|
sessionId: Scalars['String']['output'];
|
|
/** SerializedViewerState, only null if DISCONNECTED */
|
|
state?: Maybe<Scalars['JSONObject']['output']>;
|
|
status: ViewerUserActivityStatus;
|
|
user?: Maybe<LimitedUser>;
|
|
userId?: Maybe<Scalars['String']['output']>;
|
|
userName: Scalars['String']['output'];
|
|
};
|
|
|
|
export type ViewerUserActivityMessageInput = {
|
|
sessionId: Scalars['String']['input'];
|
|
/** SerializedViewerState, only null if DISCONNECTED */
|
|
state?: InputMaybe<Scalars['JSONObject']['input']>;
|
|
status: ViewerUserActivityStatus;
|
|
userId?: InputMaybe<Scalars['String']['input']>;
|
|
userName: Scalars['String']['input'];
|
|
};
|
|
|
|
export enum ViewerUserActivityStatus {
|
|
Disconnected = 'DISCONNECTED',
|
|
Viewing = 'VIEWING'
|
|
}
|
|
|
|
export type Webhook = {
|
|
__typename?: 'Webhook';
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
enabled?: Maybe<Scalars['Boolean']['output']>;
|
|
hasSecret: Scalars['Boolean']['output'];
|
|
history?: Maybe<WebhookEventCollection>;
|
|
id: Scalars['String']['output'];
|
|
projectId: Scalars['String']['output'];
|
|
streamId: Scalars['String']['output'];
|
|
triggers: Array<Scalars['String']['output']>;
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
|
|
export type WebhookHistoryArgs = {
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type WebhookCollection = {
|
|
__typename?: 'WebhookCollection';
|
|
items: Array<Webhook>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WebhookCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
enabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
secret?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
triggers: Array<Scalars['String']['input']>;
|
|
url: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WebhookDeleteInput = {
|
|
id: Scalars['String']['input'];
|
|
streamId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WebhookEvent = {
|
|
__typename?: 'WebhookEvent';
|
|
id: Scalars['String']['output'];
|
|
lastUpdate: Scalars['DateTime']['output'];
|
|
payload: Scalars['String']['output'];
|
|
retryCount: Scalars['Int']['output'];
|
|
status: Scalars['Int']['output'];
|
|
statusInfo: Scalars['String']['output'];
|
|
webhookId: Scalars['String']['output'];
|
|
};
|
|
|
|
export type WebhookEventCollection = {
|
|
__typename?: 'WebhookEventCollection';
|
|
items?: Maybe<Array<Maybe<WebhookEvent>>>;
|
|
totalCount?: Maybe<Scalars['Int']['output']>;
|
|
};
|
|
|
|
export type WebhookUpdateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
enabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
id: Scalars['String']['input'];
|
|
secret?: InputMaybe<Scalars['String']['input']>;
|
|
streamId: Scalars['String']['input'];
|
|
triggers?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
url?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type Workspace = {
|
|
__typename?: 'Workspace';
|
|
/** Get all join requests for all the workspaces the user is an admin of */
|
|
adminWorkspacesJoinRequests?: Maybe<WorkspaceJoinRequestCollection>;
|
|
automateFunctions: AutomateFunctionCollection;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
/** Info about the workspace creation state */
|
|
creationState?: Maybe<WorkspaceCreationState>;
|
|
customerPortalUrl?: Maybe<Scalars['String']['output']>;
|
|
/**
|
|
* The default role workspace members will receive for workspace projects.
|
|
* @deprecated Always the reviewer role. Will be removed in the future.
|
|
*/
|
|
defaultProjectRole: Scalars['String']['output'];
|
|
/**
|
|
* The default region where project data will be stored, if set. If undefined, defaults to main/default
|
|
* region.
|
|
*/
|
|
defaultRegion?: Maybe<ServerRegionItem>;
|
|
description?: Maybe<Scalars['String']['output']>;
|
|
/** Enable/Disable discovery of the workspace */
|
|
discoverabilityEnabled: Scalars['Boolean']['output'];
|
|
/** Enable/Disable restriction to invite users to workspace as Guests only */
|
|
domainBasedMembershipProtectionEnabled: Scalars['Boolean']['output'];
|
|
/** Verified workspace domains */
|
|
domains?: Maybe<Array<WorkspaceDomain>>;
|
|
hasAccessToFeature: Scalars['Boolean']['output'];
|
|
id: Scalars['ID']['output'];
|
|
/** Only available to workspace owners/members */
|
|
invitedTeam?: Maybe<Array<PendingWorkspaceCollaborator>>;
|
|
/** Logo image as base64-encoded string */
|
|
logo?: Maybe<Scalars['String']['output']>;
|
|
name: Scalars['String']['output'];
|
|
permissions: WorkspacePermissionChecks;
|
|
plan?: Maybe<WorkspacePlan>;
|
|
/** Shows the plan prices localized for the given workspace */
|
|
planPrices?: Maybe<WorkspacePaidPlanPrices>;
|
|
projects: ProjectCollection;
|
|
/** A Workspace is marked as readOnly if its trial period is finished or a paid plan is subscribed but payment has failed */
|
|
readOnly: Scalars['Boolean']['output'];
|
|
/** Active user's role for this workspace. `null` if request is not authenticated, or the workspace is not explicitly shared with you. */
|
|
role?: Maybe<Scalars['String']['output']>;
|
|
/** Active user's seat type for this workspace. `null` if request is not authenticated, or the workspace is not explicitly shared with you. */
|
|
seatType?: Maybe<WorkspaceSeatType>;
|
|
seats?: Maybe<WorkspaceSubscriptionSeats>;
|
|
slug: Scalars['String']['output'];
|
|
/** Information about the workspace's SSO configuration and the current user's SSO session, if present */
|
|
sso?: Maybe<WorkspaceSso>;
|
|
subscription?: Maybe<WorkspaceSubscription>;
|
|
team: WorkspaceCollaboratorCollection;
|
|
teamByRole: WorkspaceTeamByRole;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
|
|
export type WorkspaceAdminWorkspacesJoinRequestsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<AdminWorkspaceJoinRequestFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceAutomateFunctionsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<AutomateFunctionsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceHasAccessToFeatureArgs = {
|
|
featureName: WorkspaceFeatureName;
|
|
};
|
|
|
|
|
|
export type WorkspaceInvitedTeamArgs = {
|
|
filter?: InputMaybe<PendingWorkspaceCollaboratorsFilter>;
|
|
};
|
|
|
|
|
|
export type WorkspaceProjectsArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<WorkspaceProjectsFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceTeamArgs = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
filter?: InputMaybe<WorkspaceTeamFilter>;
|
|
limit?: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type WorkspaceBillingMutations = {
|
|
__typename?: 'WorkspaceBillingMutations';
|
|
cancelCheckoutSession: Scalars['Boolean']['output'];
|
|
createCheckoutSession: CheckoutSession;
|
|
upgradePlan: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type WorkspaceBillingMutationsCancelCheckoutSessionArgs = {
|
|
input: CancelCheckoutSessionInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceBillingMutationsCreateCheckoutSessionArgs = {
|
|
input: CheckoutSessionInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceBillingMutationsUpgradePlanArgs = {
|
|
input: UpgradePlanInput;
|
|
};
|
|
|
|
/** Overridden by `WorkspaceCollaboratorGraphQLReturn` */
|
|
export type WorkspaceCollaborator = {
|
|
__typename?: 'WorkspaceCollaborator';
|
|
id: Scalars['ID']['output'];
|
|
/** Date that the user joined the workspace. */
|
|
joinDate: Scalars['DateTime']['output'];
|
|
projectRoles: Array<ProjectRole>;
|
|
role: Scalars['String']['output'];
|
|
seatType?: Maybe<WorkspaceSeatType>;
|
|
user: LimitedUser;
|
|
};
|
|
|
|
export type WorkspaceCollaboratorCollection = {
|
|
__typename?: 'WorkspaceCollaboratorCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<WorkspaceCollaborator>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WorkspaceCollection = {
|
|
__typename?: 'WorkspaceCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<Workspace>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WorkspaceCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
/** Add this domain to the workspace as a verified domain and enable domain discoverability */
|
|
enableDomainDiscoverabilityForDomain?: InputMaybe<Scalars['String']['input']>;
|
|
/** Logo image as base64-encoded string */
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name: Scalars['String']['input'];
|
|
slug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspaceCreationState = {
|
|
__typename?: 'WorkspaceCreationState';
|
|
completed: Scalars['Boolean']['output'];
|
|
state: Scalars['JSONObject']['output'];
|
|
};
|
|
|
|
export type WorkspaceCreationStateInput = {
|
|
completed: Scalars['Boolean']['input'];
|
|
state: Scalars['JSONObject']['input'];
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type WorkspaceDismissInput = {
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export type WorkspaceDomain = {
|
|
__typename?: 'WorkspaceDomain';
|
|
domain: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
};
|
|
|
|
export type WorkspaceDomainDeleteInput = {
|
|
id: Scalars['ID']['input'];
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export enum WorkspaceFeatureName {
|
|
DomainBasedSecurityPolicies = 'domainBasedSecurityPolicies',
|
|
OidcSso = 'oidcSso',
|
|
WorkspaceDataRegionSpecificity = 'workspaceDataRegionSpecificity'
|
|
}
|
|
|
|
export type WorkspaceInviteCreateInput = {
|
|
/** Either this or userId must be filled */
|
|
email?: InputMaybe<Scalars['String']['input']>;
|
|
/** Defaults to the member role, if not specified */
|
|
role?: InputMaybe<WorkspaceRole>;
|
|
/** Defaults to User, if not specified */
|
|
serverRole?: InputMaybe<ServerRole>;
|
|
/** Either this or email must be filled */
|
|
userId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspaceInviteLookupOptions = {
|
|
/** If true, the query will assume workspaceId is actually the workspace slug, and do the lookup by slug */
|
|
useSlug?: InputMaybe<Scalars['Boolean']['input']>;
|
|
};
|
|
|
|
export type WorkspaceInviteMutations = {
|
|
__typename?: 'WorkspaceInviteMutations';
|
|
batchCreate: Workspace;
|
|
cancel: Workspace;
|
|
create: Workspace;
|
|
resend: Scalars['Boolean']['output'];
|
|
use: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type WorkspaceInviteMutationsBatchCreateArgs = {
|
|
input: Array<WorkspaceInviteCreateInput>;
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceInviteMutationsCancelArgs = {
|
|
inviteId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceInviteMutationsCreateArgs = {
|
|
input: WorkspaceInviteCreateInput;
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceInviteMutationsResendArgs = {
|
|
input: WorkspaceInviteResendInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceInviteMutationsUseArgs = {
|
|
input: WorkspaceInviteUseInput;
|
|
};
|
|
|
|
export type WorkspaceInviteResendInput = {
|
|
inviteId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceInviteUseInput = {
|
|
accept: Scalars['Boolean']['input'];
|
|
/**
|
|
* If invite is attached to an unregistered email, the invite can only be used if this is set to true.
|
|
* Upon accepting such an invite, the unregistered email will be added to the user's account as well.
|
|
*/
|
|
addNewEmail?: InputMaybe<Scalars['Boolean']['input']>;
|
|
token: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceJoinRequest = {
|
|
__typename?: 'WorkspaceJoinRequest';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
id: Scalars['String']['output'];
|
|
status: WorkspaceJoinRequestStatus;
|
|
user: LimitedUser;
|
|
workspace: Workspace;
|
|
};
|
|
|
|
export type WorkspaceJoinRequestCollection = {
|
|
__typename?: 'WorkspaceJoinRequestCollection';
|
|
cursor?: Maybe<Scalars['String']['output']>;
|
|
items: Array<WorkspaceJoinRequest>;
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WorkspaceJoinRequestFilter = {
|
|
status?: InputMaybe<WorkspaceJoinRequestStatus>;
|
|
};
|
|
|
|
export type WorkspaceJoinRequestMutations = {
|
|
__typename?: 'WorkspaceJoinRequestMutations';
|
|
approve: Scalars['Boolean']['output'];
|
|
deny: Scalars['Boolean']['output'];
|
|
};
|
|
|
|
|
|
export type WorkspaceJoinRequestMutationsApproveArgs = {
|
|
input: ApproveWorkspaceJoinRequestInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceJoinRequestMutationsDenyArgs = {
|
|
input: DenyWorkspaceJoinRequestInput;
|
|
};
|
|
|
|
export enum WorkspaceJoinRequestStatus {
|
|
Approved = 'approved',
|
|
Denied = 'denied',
|
|
Pending = 'pending'
|
|
}
|
|
|
|
export type WorkspaceMutations = {
|
|
__typename?: 'WorkspaceMutations';
|
|
addDomain: Workspace;
|
|
billing: WorkspaceBillingMutations;
|
|
create: Workspace;
|
|
delete: Scalars['Boolean']['output'];
|
|
deleteDomain: Workspace;
|
|
deleteSsoProvider: Scalars['Boolean']['output'];
|
|
/** Dismiss a workspace from the discoverable list, behind the scene a join request is created with the status "dismissed" */
|
|
dismiss: Scalars['Boolean']['output'];
|
|
invites: WorkspaceInviteMutations;
|
|
join: Workspace;
|
|
leave: Scalars['Boolean']['output'];
|
|
projects: WorkspaceProjectMutations;
|
|
requestToJoin: Scalars['Boolean']['output'];
|
|
/** Set the default region where project data will be stored. Only available to admins. */
|
|
setDefaultRegion: Workspace;
|
|
update: Workspace;
|
|
updateCreationState: Scalars['Boolean']['output'];
|
|
updateRole: Workspace;
|
|
updateSeatType: Workspace;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsAddDomainArgs = {
|
|
input: AddDomainToWorkspaceInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsCreateArgs = {
|
|
input: WorkspaceCreateInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsDeleteArgs = {
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsDeleteDomainArgs = {
|
|
input: WorkspaceDomainDeleteInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsDeleteSsoProviderArgs = {
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsDismissArgs = {
|
|
input: WorkspaceDismissInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsJoinArgs = {
|
|
input: JoinWorkspaceInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsLeaveArgs = {
|
|
id: Scalars['ID']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsRequestToJoinArgs = {
|
|
input: WorkspaceRequestToJoinInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsSetDefaultRegionArgs = {
|
|
regionKey: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsUpdateArgs = {
|
|
input: WorkspaceUpdateInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsUpdateCreationStateArgs = {
|
|
input: WorkspaceCreationStateInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsUpdateRoleArgs = {
|
|
input: WorkspaceRoleUpdateInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceMutationsUpdateSeatTypeArgs = {
|
|
input: WorkspaceUpdateSeatTypeInput;
|
|
};
|
|
|
|
export type WorkspacePaidPlanPrices = {
|
|
__typename?: 'WorkspacePaidPlanPrices';
|
|
pro: WorkspacePlanPrice;
|
|
proUnlimited: WorkspacePlanPrice;
|
|
team: WorkspacePlanPrice;
|
|
teamUnlimited: WorkspacePlanPrice;
|
|
};
|
|
|
|
export enum WorkspacePaymentMethod {
|
|
Billing = 'billing',
|
|
Invoice = 'invoice',
|
|
Unpaid = 'unpaid'
|
|
}
|
|
|
|
export type WorkspacePermissionChecks = {
|
|
__typename?: 'WorkspacePermissionChecks';
|
|
canCreateProject: PermissionCheckResult;
|
|
canMoveProjectToWorkspace: PermissionCheckResult;
|
|
};
|
|
|
|
|
|
export type WorkspacePermissionChecksCanMoveProjectToWorkspaceArgs = {
|
|
projectId?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspacePlan = {
|
|
__typename?: 'WorkspacePlan';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
name: WorkspacePlans;
|
|
paymentMethod: WorkspacePaymentMethod;
|
|
status: WorkspacePlanStatuses;
|
|
usage: WorkspacePlanUsage;
|
|
};
|
|
|
|
export type WorkspacePlanPrice = {
|
|
__typename?: 'WorkspacePlanPrice';
|
|
monthly: Price;
|
|
yearly: Price;
|
|
};
|
|
|
|
export enum WorkspacePlanStatuses {
|
|
CancelationScheduled = 'cancelationScheduled',
|
|
Canceled = 'canceled',
|
|
PaymentFailed = 'paymentFailed',
|
|
Valid = 'valid'
|
|
}
|
|
|
|
export type WorkspacePlanUsage = {
|
|
__typename?: 'WorkspacePlanUsage';
|
|
modelCount: Scalars['Int']['output'];
|
|
projectCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export enum WorkspacePlans {
|
|
Academia = 'academia',
|
|
Free = 'free',
|
|
Pro = 'pro',
|
|
ProUnlimited = 'proUnlimited',
|
|
ProUnlimitedInvoiced = 'proUnlimitedInvoiced',
|
|
Team = 'team',
|
|
TeamUnlimited = 'teamUnlimited',
|
|
TeamUnlimitedInvoiced = 'teamUnlimitedInvoiced',
|
|
Unlimited = 'unlimited'
|
|
}
|
|
|
|
export type WorkspaceProjectCreateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
visibility?: InputMaybe<ProjectVisibility>;
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceProjectInviteCreateInput = {
|
|
/** Either this or userId must be filled */
|
|
email?: InputMaybe<Scalars['String']['input']>;
|
|
/** Defaults to the contributor role, if not specified */
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
/** Can only be specified if guest mode is on or if the user is an admin */
|
|
serverRole?: InputMaybe<Scalars['String']['input']>;
|
|
/** Either this or email must be filled */
|
|
userId?: InputMaybe<Scalars['String']['input']>;
|
|
/** Only taken into account, if project belongs to a workspace. Defaults to guest access. */
|
|
workspaceRole?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspaceProjectMutations = {
|
|
__typename?: 'WorkspaceProjectMutations';
|
|
create: Project;
|
|
/**
|
|
* Schedule a job that will:
|
|
* - Move all regional data to target region
|
|
* - Update project region key
|
|
* - TODO: Eventually delete data in previous region
|
|
*/
|
|
moveToRegion: Scalars['String']['output'];
|
|
moveToWorkspace: Project;
|
|
updateRole: Project;
|
|
};
|
|
|
|
|
|
export type WorkspaceProjectMutationsCreateArgs = {
|
|
input: WorkspaceProjectCreateInput;
|
|
};
|
|
|
|
|
|
export type WorkspaceProjectMutationsMoveToRegionArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
regionKey: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceProjectMutationsMoveToWorkspaceArgs = {
|
|
projectId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
|
|
export type WorkspaceProjectMutationsUpdateRoleArgs = {
|
|
input: ProjectUpdateRoleInput;
|
|
};
|
|
|
|
export type WorkspaceProjectsFilter = {
|
|
/** Filter out projects by name */
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
/** Only return workspace projects that the active user has an explicit project role in */
|
|
withProjectRoleOnly?: InputMaybe<Scalars['Boolean']['input']>;
|
|
};
|
|
|
|
export type WorkspaceProjectsUpdatedMessage = {
|
|
__typename?: 'WorkspaceProjectsUpdatedMessage';
|
|
/** Project entity, null if project was deleted */
|
|
project?: Maybe<Project>;
|
|
/** Project ID */
|
|
projectId: Scalars['String']['output'];
|
|
/** Message type */
|
|
type: WorkspaceProjectsUpdatedMessageType;
|
|
/** Workspace ID */
|
|
workspaceId: Scalars['String']['output'];
|
|
};
|
|
|
|
export enum WorkspaceProjectsUpdatedMessageType {
|
|
Added = 'ADDED',
|
|
Removed = 'REMOVED'
|
|
}
|
|
|
|
export type WorkspaceRequestToJoinInput = {
|
|
workspaceId: Scalars['ID']['input'];
|
|
};
|
|
|
|
export enum WorkspaceRole {
|
|
Admin = 'ADMIN',
|
|
Guest = 'GUEST',
|
|
Member = 'MEMBER'
|
|
}
|
|
|
|
export type WorkspaceRoleCollection = {
|
|
__typename?: 'WorkspaceRoleCollection';
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WorkspaceRoleDeleteInput = {
|
|
userId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceRoleUpdateInput = {
|
|
/** Leave role null to revoke access entirely */
|
|
role?: InputMaybe<Scalars['String']['input']>;
|
|
userId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceSeatCollection = {
|
|
__typename?: 'WorkspaceSeatCollection';
|
|
totalCount: Scalars['Int']['output'];
|
|
};
|
|
|
|
export enum WorkspaceSeatType {
|
|
Editor = 'editor',
|
|
Viewer = 'viewer'
|
|
}
|
|
|
|
export type WorkspaceSeatsByType = {
|
|
__typename?: 'WorkspaceSeatsByType';
|
|
editors?: Maybe<WorkspaceSeatCollection>;
|
|
viewers?: Maybe<WorkspaceSeatCollection>;
|
|
};
|
|
|
|
export type WorkspaceSso = {
|
|
__typename?: 'WorkspaceSso';
|
|
/** If null, the workspace does not have SSO configured */
|
|
provider?: Maybe<WorkspaceSsoProvider>;
|
|
session?: Maybe<WorkspaceSsoSession>;
|
|
};
|
|
|
|
export type WorkspaceSsoProvider = {
|
|
__typename?: 'WorkspaceSsoProvider';
|
|
clientId: Scalars['String']['output'];
|
|
id: Scalars['ID']['output'];
|
|
issuerUrl: Scalars['String']['output'];
|
|
name: Scalars['String']['output'];
|
|
};
|
|
|
|
export type WorkspaceSsoSession = {
|
|
__typename?: 'WorkspaceSsoSession';
|
|
createdAt: Scalars['DateTime']['output'];
|
|
validUntil: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
export type WorkspaceSubscription = {
|
|
__typename?: 'WorkspaceSubscription';
|
|
billingInterval: BillingInterval;
|
|
createdAt: Scalars['DateTime']['output'];
|
|
currency: Currency;
|
|
currentBillingCycleEnd: Scalars['DateTime']['output'];
|
|
seats: WorkspaceSubscriptionSeats;
|
|
updatedAt: Scalars['DateTime']['output'];
|
|
};
|
|
|
|
export type WorkspaceSubscriptionSeatCount = {
|
|
__typename?: 'WorkspaceSubscriptionSeatCount';
|
|
/** Total number of seats in use by workspace users */
|
|
assigned: Scalars['Int']['output'];
|
|
/** Total number of seats purchased and available in the current subscription cycle */
|
|
available: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type WorkspaceSubscriptionSeats = {
|
|
__typename?: 'WorkspaceSubscriptionSeats';
|
|
editors: WorkspaceSubscriptionSeatCount;
|
|
viewers: WorkspaceSubscriptionSeatCount;
|
|
};
|
|
|
|
export type WorkspaceTeamByRole = {
|
|
__typename?: 'WorkspaceTeamByRole';
|
|
admins?: Maybe<WorkspaceRoleCollection>;
|
|
guests?: Maybe<WorkspaceRoleCollection>;
|
|
members?: Maybe<WorkspaceRoleCollection>;
|
|
};
|
|
|
|
export type WorkspaceTeamFilter = {
|
|
/** Limit team members to provided role(s) */
|
|
roles?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
/** Search for team members by name or email */
|
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
seatType?: InputMaybe<WorkspaceSeatType>;
|
|
};
|
|
|
|
export type WorkspaceUpdateInput = {
|
|
description?: InputMaybe<Scalars['String']['input']>;
|
|
discoverabilityEnabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
domainBasedMembershipProtectionEnabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
id: Scalars['String']['input'];
|
|
/** Logo image as base64-encoded string */
|
|
logo?: InputMaybe<Scalars['String']['input']>;
|
|
name?: InputMaybe<Scalars['String']['input']>;
|
|
slug?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type WorkspaceUpdateSeatTypeInput = {
|
|
seatType: WorkspaceSeatType;
|
|
userId: Scalars['String']['input'];
|
|
workspaceId: Scalars['String']['input'];
|
|
};
|
|
|
|
export type WorkspaceUpdatedMessage = {
|
|
__typename?: 'WorkspaceUpdatedMessage';
|
|
/** Workspace ID */
|
|
id: Scalars['String']['output'];
|
|
/** Workspace itself */
|
|
workspace: Workspace;
|
|
};
|
|
|
|
export type AcccountTestQueryQueryVariables = Exact<{ [key: string]: never; }>;
|
|
|
|
|
|
export type AcccountTestQueryQuery = { __typename?: 'Query', serverInfo: { __typename?: 'ServerInfo', version?: string | null, name: string, company?: string | null } };
|
|
|
|
|
|
export const AcccountTestQueryDocument = {"kind":"Document","definitions":[{"kind":"OperationDefinition","operation":"query","name":{"kind":"Name","value":"AcccountTestQuery"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"serverInfo"},"selectionSet":{"kind":"SelectionSet","selections":[{"kind":"Field","name":{"kind":"Name","value":"version"}},{"kind":"Field","name":{"kind":"Name","value":"name"}},{"kind":"Field","name":{"kind":"Name","value":"company"}}]}}]}}]} as unknown as DocumentNode<AcccountTestQueryQuery, AcccountTestQueryQueryVariables>; |