Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b

crates/graphql/src/api/mutations/add_invite_link_domain_restriction.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation addInviteLinkDomainRestriction($requestContext: RequestContext!, $input: AddInviteLinkDomainRestrictionInput!) {
+  addInviteLinkDomainRestriction(requestContext: $requestContext, input:$input) {
+    ... on AddInviteLinkDomainRestrictionOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::InputObject, Debug)]
+pub struct AddInviteLinkDomainRestrictionInput {
+    pub domain: String,
+    pub team_uid: cynic::Id,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct AddInviteLinkDomainRestrictionVariables {
+    pub input: AddInviteLinkDomainRestrictionInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "AddInviteLinkDomainRestrictionVariables"
+)]
+pub struct AddInviteLinkDomainRestriction {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub add_invite_link_domain_restriction: AddInviteLinkDomainRestrictionResult,
+}
+crate::client::define_operation! {
+    add_invite_link_domain_restriction(AddInviteLinkDomainRestrictionVariables) -> AddInviteLinkDomainRestriction;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct AddInviteLinkDomainRestrictionOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum AddInviteLinkDomainRestrictionResult {
+    AddInviteLinkDomainRestrictionOutput(AddInviteLinkDomainRestrictionOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/add_object_guests.rs

@@ -0,0 +1,46 @@
+use crate::{
+    error::UserFacingError,
+    object_permissions::{AccessLevel, ObjectPermissions},
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+    user::PublicUserProfile,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct AddObjectGuestsVariables {
+    pub input: AddObjectGuestsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "AddObjectGuestsVariables")]
+pub struct AddObjectGuests {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub add_object_guests: AddObjectGuestsResult,
+}
+crate::client::define_operation! {
+    add_object_guests(AddObjectGuestsVariables) -> AddObjectGuests;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct AddObjectGuestsOutput {
+    pub object_permissions: ObjectPermissions,
+    pub response_context: ResponseContext,
+    pub user_profiles: Option<Vec<PublicUserProfile>>,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum AddObjectGuestsResult {
+    AddObjectGuestsOutput(AddObjectGuestsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct AddObjectGuestsInput {
+    pub access_level: AccessLevel,
+    pub object_uid: cynic::Id,
+    pub user_emails: Vec<String>,
+}

crates/graphql/src/api/mutations/bulk_create_objects.rs

@@ -0,0 +1,55 @@
+use super::create_generic_string_object::CreateGenericStringObjectOutput;
+use crate::{
+    error::UserFacingError, generic_string_object::GenericStringObjectInput,
+    object_permissions::Owner, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct BulkCreateObjectsVariables {
+    pub input: BulkCreateObjectsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "BulkCreateObjectsVariables"
+)]
+pub struct BulkCreateObjects {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub bulk_create_objects: BulkCreateObjectsResult,
+}
+crate::client::define_operation! {
+    bulk_create_objects(BulkCreateObjectsVariables) -> BulkCreateObjects;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct BulkCreateObjectsOutput {
+    pub generic_string_objects: Option<BulkCreateGenericStringObjectsOutput>,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct BulkCreateGenericStringObjectsOutput {
+    pub objects: Vec<CreateGenericStringObjectOutput>,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum BulkCreateObjectsResult {
+    BulkCreateObjectsOutput(BulkCreateObjectsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct BulkCreateObjectsInput {
+    pub generic_string_objects: Option<BulkCreateGenericStringObjectsInput>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct BulkCreateGenericStringObjectsInput {
+    pub objects: Vec<GenericStringObjectInput>,
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/confirm_file_artifact_upload.rs

@@ -0,0 +1,46 @@
+use super::create_file_artifact_upload_target::FileArtifact;
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ConfirmFileArtifactUploadVariables {
+    pub input: ConfirmFileArtifactUploadInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "ConfirmFileArtifactUploadVariables"
+)]
+pub struct ConfirmFileArtifactUpload {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub confirm_file_artifact_upload: ConfirmFileArtifactUploadResult,
+}
+
+crate::client::define_operation! {
+    confirm_file_artifact_upload(ConfirmFileArtifactUploadVariables) -> ConfirmFileArtifactUpload;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum ConfirmFileArtifactUploadResult {
+    ConfirmFileArtifactUploadOutput(ConfirmFileArtifactUploadOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct ConfirmFileArtifactUploadOutput {
+    pub artifact: FileArtifact,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+#[cynic(graphql_type = "ConfirmFileArtifactUploadInput")]
+pub struct ConfirmFileArtifactUploadInput {
+    pub artifact_uid: cynic::Id,
+    pub checksum: String,
+}

crates/graphql/src/api/mutations/create_agent_task.rs

@@ -0,0 +1,47 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateAgentTaskVariables {
+    pub input: CreateAgentTaskInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "CreateAgentTaskVariables")]
+pub struct CreateAgentTask {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_agent_task: CreateAgentTaskResult,
+}
+
+crate::client::define_operation! {
+    create_agent_task(CreateAgentTaskVariables) -> CreateAgentTask;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum CreateAgentTaskResult {
+    CreateAgentTaskOutput(CreateAgentTaskOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateAgentTaskOutput {
+    pub response_context: ResponseContext,
+    pub task_id: cynic::Id,
+}
+
+#[derive(cynic::InputObject, Debug)]
+#[cynic(graphql_type = "CreateAgentTaskInput")]
+pub struct CreateAgentTaskInput {
+    pub prompt: String,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub environment_uid: Option<cynic::Id>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub parent_run_id: Option<cynic::Id>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub agent_config_snapshot: Option<String>,
+}

crates/graphql/src/api/mutations/create_anonymous_user.rs

@@ -0,0 +1,66 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateAnonymousUserVariables {
+    pub input: CreateAnonymousUserInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateAnonymousUserInput {
+    pub anonymous_user_type: AnonymousUserType,
+    pub expiration_type: AnonymousUserExpirationType,
+    pub referral_code: Option<String>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "CreateAnonymousUserVariables"
+)]
+pub struct CreateAnonymousUser {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_anonymous_user: CreateAnonymousUserResult,
+}
+crate::client::define_operation! {
+    create_anonymous_user(CreateAnonymousUserVariables) -> CreateAnonymousUser;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateAnonymousUserOutput {
+    pub expires_at: Option<Time>,
+    pub anonymous_user_type: AnonymousUserType,
+    pub firebase_uid: String,
+    pub id_token: String,
+    pub is_invite_valid: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum CreateAnonymousUserResult {
+    CreateAnonymousUserOutput(CreateAnonymousUserOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum AnonymousUserExpirationType {
+    #[cynic(rename = "EXPIRATION_14_DAYS")]
+    Expiration14Days,
+    #[cynic(rename = "NO_EXPIRATION")]
+    NoExpiration,
+}
+
+#[derive(cynic::Enum, Clone, Debug)]
+pub enum AnonymousUserType {
+    NativeClientAnonymousUser,
+    NativeClientAnonymousUserFeatureGated,
+    WebClientAnonymousUser,
+    #[cynic(fallback)]
+    Other(String),
+}

crates/graphql/src/api/mutations/create_file_artifact_upload_target.rs

@@ -0,0 +1,79 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateFileArtifactUploadTargetVariables {
+    pub input: CreateFileArtifactUploadTargetInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "CreateFileArtifactUploadTargetVariables"
+)]
+pub struct CreateFileArtifactUploadTarget {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_file_artifact_upload_target: CreateFileArtifactUploadTargetResult,
+}
+
+crate::client::define_operation! {
+    create_file_artifact_upload_target(CreateFileArtifactUploadTargetVariables) -> CreateFileArtifactUploadTarget;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum CreateFileArtifactUploadTargetResult {
+    CreateFileArtifactUploadTargetOutput(CreateFileArtifactUploadTargetOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateFileArtifactUploadTargetOutput {
+    pub artifact: FileArtifact,
+    pub response_context: ResponseContext,
+    pub upload_target: FileArtifactUploadTarget,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct FileArtifact {
+    pub artifact_uid: cynic::Id,
+    pub filepath: String,
+    pub description: Option<String>,
+    pub mime_type: String,
+    pub size_bytes: Option<i32>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "CreateUploadTarget")]
+pub struct FileArtifactUploadTarget {
+    pub url: String,
+    pub method: String,
+    pub headers: Vec<FileArtifactUploadHeader>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "CreateUploadTargetHeader")]
+pub struct FileArtifactUploadHeader {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(cynic::InputObject, Debug)]
+#[cynic(graphql_type = "CreateFileArtifactUploadTargetInput")]
+pub struct CreateFileArtifactUploadTargetInput {
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub conversation_id: Option<cynic::Id>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<cynic::Id>,
+    pub filepath: String,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub mime_type: Option<String>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub size_bytes: Option<i32>,
+}

crates/graphql/src/api/mutations/create_folder.rs

@@ -0,0 +1,42 @@
+use crate::{
+    error::UserFacingError, folder::Folder, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateFolderVariables {
+    pub input: CreateFolderInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "CreateFolderVariables")]
+pub struct CreateFolder {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_folder: CreateFolderResult,
+}
+crate::client::define_operation! {
+    create_folder(CreateFolderVariables) -> CreateFolder;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateFolderOutput {
+    pub folder: Folder,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateFolderResult {
+    CreateFolderOutput(CreateFolderOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateFolderInput {
+    pub initial_folder_id: Option<cynic::Id>,
+    pub name: String,
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/create_generic_string_object.rs

@@ -0,0 +1,51 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError,
+    generic_string_object::{GenericStringObject, GenericStringObjectInput},
+    object_permissions::Owner,
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateGenericStringObjectVariables {
+    pub input: CreateGenericStringObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "CreateGenericStringObjectVariables"
+)]
+pub struct CreateGenericStringObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_generic_string_object: CreateGenericStringObjectResult,
+}
+crate::client::define_operation! {
+    create_generic_string_object(CreateGenericStringObjectVariables) -> CreateGenericStringObject;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateGenericStringObjectOutput {
+    pub client_id: cynic::Id,
+    pub generic_string_object: GenericStringObject,
+    pub response_context: ResponseContext,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateGenericStringObjectResult {
+    CreateGenericStringObjectOutput(CreateGenericStringObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateGenericStringObjectInput {
+    pub generic_string_object: GenericStringObjectInput,
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/create_managed_secret.rs

@@ -0,0 +1,53 @@
+use crate::{
+    error::UserFacingError,
+    managed_secrets::{ManagedSecret, ManagedSecretType},
+    object_permissions::Owner,
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateManagedSecretVariables {
+    pub input: CreateManagedSecretInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "CreateManagedSecretVariables"
+)]
+pub struct CreateManagedSecret {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_managed_secret: CreateManagedSecretResult,
+}
+
+crate::client::define_operation! {
+    create_managed_secret(CreateManagedSecretVariables) -> CreateManagedSecret;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateManagedSecretOutput {
+    pub managed_secret: ManagedSecret,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateManagedSecretResult {
+    CreateManagedSecretOutput(CreateManagedSecretOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateManagedSecretInput {
+    pub description: Option<String>,
+    pub encrypted_value: String,
+    pub name: String,
+    pub owner: Owner,
+    #[cynic(rename = "type")]
+    pub type_: ManagedSecretType,
+}

crates/graphql/src/api/mutations/create_notebook.rs

@@ -0,0 +1,49 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, notebook::Notebook, object::CloudObjectEventEntrypoint,
+    object_permissions::Owner, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateNotebookVariables {
+    pub input: CreateNotebookInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateNotebookInput {
+    pub ai_document_id: Option<String>,
+    pub conversation_id: Option<String>,
+    pub data: Option<String>,
+    pub entrypoint: CloudObjectEventEntrypoint,
+    pub initial_folder_id: Option<cynic::Id>,
+    pub owner: Owner,
+    pub title: Option<String>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "CreateNotebookVariables")]
+pub struct CreateNotebook {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_notebook: CreateNotebookResult,
+}
+crate::client::define_operation! {
+    create_notebook(CreateNotebookVariables) -> CreateNotebook;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateNotebookOutput {
+    pub notebook: Notebook,
+    pub response_context: ResponseContext,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateNotebookResult {
+    CreateNotebookOutput(CreateNotebookOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/create_simple_integration.rs

@@ -0,0 +1,54 @@
+use crate::{error::UserFacingError, request_context::RequestContext, schema};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateSimpleIntegrationVariables {
+    pub config: SimpleIntegrationConfig,
+    pub enabled: bool,
+    pub integration_type: String,
+    pub is_update: bool,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SimpleIntegrationConfig {
+    // For these fields, None means "don't change".
+    // For base_prompt/environment_uid/model_id, Some("") means "clear".
+    // Note: mcp_servers_json is treated as patch data; on update, an empty string is a no-op.
+    pub base_prompt: Option<String>,
+    pub environment_uid: Option<String>,
+    pub model_id: Option<String>,
+    pub mcp_servers_json: Option<String>,
+    pub remove_mcp_server_names: Option<Vec<String>>,
+    pub worker_host: Option<String>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "CreateSimpleIntegrationVariables"
+)]
+pub struct CreateSimpleIntegration {
+    #[arguments(input: { config: $config, enabled: $enabled, integrationType: $integration_type, isUpdate: $is_update }, requestContext: $request_context)]
+    pub create_simple_integration: CreateSimpleIntegrationResult,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateSimpleIntegrationOutput {
+    pub auth_url: Option<String>,
+    pub success: bool,
+    pub message: String,
+    #[cynic(rename = "txId")]
+    pub tx_id: Option<cynic::Id>,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum CreateSimpleIntegrationResult {
+    CreateSimpleIntegrationOutput(CreateSimpleIntegrationOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+crate::client::define_operation! {
+    CreateSimpleIntegration(CreateSimpleIntegrationVariables) -> CreateSimpleIntegration;
+}

crates/graphql/src/api/mutations/create_team.rs

@@ -0,0 +1,157 @@
+use crate::{
+    error::UserFacingError, object::CloudObjectEventEntrypoint, request_context::RequestContext,
+    response_context::ResponseContext, schema, workspace::Workspace,
+};
+
+/*
+mutation CreateTeam($input: CreateTeamInput!, $request_context: RequestContext!) {
+  createTeam(input: $input, requestContext: $request_context) {
+    ... on CreateTeamOutput {
+      workspace {
+        uid
+        name
+        members {
+          uid
+          email
+          role
+        }
+        teams {
+          uid
+          name
+          members {
+            uid
+            email
+            role
+          }
+        }
+        billingMetadata {
+          customerType
+          delinquencyStatus
+          tier {
+            name
+            description
+            warpAiPolicy {
+              limit
+              isCodeSuggestionsToggleable
+              isPromptSuggestionsToggleable
+              isNextCommandEnabled
+              isVoiceEnabled
+            }
+            teamSizePolicy {
+              isUnlimited
+              limit
+            }
+            sharedNotebooksPolicy {
+              isUnlimited
+              limit
+            }
+            sharedWorkflowsPolicy {
+              isUnlimited
+              limit
+            }
+            sessionSharingPolicy {
+              enabled
+              maxSessionBytesSize
+            }
+            anyoneWithLinkSharingPolicy {
+              toggleable
+            }
+            directLinkSharingPolicy {
+              toggleable
+            }
+            byoApiKeyPolicy {
+              enabled
+            }
+            pricing {
+              enablePayAsYouGo
+              autoReloadCreditDenomination
+              autoReloadCostCents
+            }
+          }
+          serviceAgreements {
+            currentPeriodEnd
+            status
+            stripeSubscriptionId
+            type
+          }
+        }
+        settings {
+          isDiscoverable
+          isInviteLinkEnabled
+          llmSettings {
+            enabled
+          }
+          telemetrySettings {
+            forceEnabled
+          }
+          linkSharingSettings {
+            anyoneWithLinkSharingEnabled
+            directLinkSharingEnabled
+          }
+        }
+        hasBillingHistory
+        inviteCode
+        pendingEmailInvites {
+          email
+          expired
+        }
+        inviteLinkDomainRestrictions {
+          uid
+          domain
+        }
+        stripeCustomerId
+        isEligibleForDiscovery
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateTeamVariables {
+    pub input: CreateTeamInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateTeamInput {
+    pub discoverable: bool,
+    pub entrypoint: CloudObjectEventEntrypoint,
+    pub name: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "CreateTeamVariables")]
+pub struct CreateTeam {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_team: CreateTeamResult,
+}
+crate::client::define_operation! {
+    create_team(CreateTeamVariables) -> CreateTeam;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateTeamResult {
+    CreateTeamOutput(CreateTeamOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateTeamOutput {
+    pub workspace: Workspace,
+    pub response_context: ResponseContext,
+}

crates/graphql/src/api/mutations/create_workflow.rs

@@ -0,0 +1,125 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, object::CloudObjectEventEntrypoint, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema, workflow::Workflow,
+};
+
+/*
+mutation CreateWorkflow($input: CreateWorkflowInput!, $requestContext: RequestContext!) {
+  createWorkflow(input: $input, requestContext: $requestContext) {
+    ... on CreateWorkflowOutput {
+      responseContext {
+        serverVersion
+      }
+      workflow {
+        data
+        metadata {
+          creatorUid
+          currentEditorUid
+          isWelcomeObject
+          lastEditorUid
+          metadataLastUpdatedTs
+          parent {
+            ... on FolderContainer {
+              folderUid
+            }
+            ... on Space {
+              uid
+              type
+            }
+          }
+          revisionTs
+          trashedTs
+          uid
+        }
+        permissions {
+          guests {
+            accessLevel
+            source {
+              ... on FolderContainer {
+                folderUid
+              }
+              ... on Space {
+                uid
+                type
+              }
+            }
+            subject {
+              ... on UserGuest {
+                firebaseUid
+              }
+            }
+          }
+          lastUpdatedTs
+          anyoneLinkSharing {
+            accessLevel
+            source {
+              ... on FolderContainer {
+                folderUid
+              }
+              ... on Space {
+                uid
+                type
+              }
+            }
+          }
+        }
+      }
+      revisionTs
+    }
+    ... on UserFacingError {
+      error {
+        message
+        ... on SharedObjectsLimitExceeded {
+          limit
+          objectType
+          message
+        }
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct CreateWorkflowVariables {
+    pub input: CreateWorkflowInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "CreateWorkflowVariables")]
+pub struct CreateWorkflow {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub create_workflow: CreateWorkflowResult,
+}
+crate::client::define_operation! {
+    create_workflow(CreateWorkflowVariables) -> CreateWorkflow;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct CreateWorkflowOutput {
+    pub response_context: ResponseContext,
+    pub workflow: Workflow,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum CreateWorkflowResult {
+    CreateWorkflowOutput(CreateWorkflowOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct CreateWorkflowInput {
+    pub data: String,
+    pub entrypoint: CloudObjectEventEntrypoint,
+    pub initial_folder_id: Option<cynic::Id>,
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/delete_ai_conversation.rs

@@ -0,0 +1,43 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct DeleteAIConversationVariables {
+    pub input: DeleteConversationInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "DeleteAIConversationVariables"
+)]
+pub struct DeleteAIConversation {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub delete_conversation: DeleteConversationResult,
+}
+crate::client::define_operation! {
+    delete_ai_conversation(DeleteAIConversationVariables) -> DeleteAIConversation;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct DeleteConversationOutput {
+    pub deleted_uid: cynic::Id,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum DeleteConversationResult {
+    DeleteConversationOutput(DeleteConversationOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct DeleteConversationInput {
+    pub conversation_id: cynic::Id,
+}

crates/graphql/src/api/mutations/delete_invite_link_domain_restriction.rs

@@ -0,0 +1,68 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation DeleteInviteLinkDomainRestriction($input:DeleteInviteLinkDomainRestrictionInput!, $request_context:RequestContext!) {
+  deleteInviteLinkDomainRestriction(
+    input:$input,
+    requestContext: $request_context
+  ) {
+    __typename
+    ... on DeleteInviteLinkDomainRestrictionOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct DeleteInviteLinkDomainRestrictionVariables {
+    pub input: DeleteInviteLinkDomainRestrictionInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "DeleteInviteLinkDomainRestrictionVariables"
+)]
+pub struct DeleteInviteLinkDomainRestriction {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub delete_invite_link_domain_restriction: DeleteInviteLinkDomainRestrictionResult,
+}
+crate::client::define_operation! {
+    delete_invite_link_domain_restriction(DeleteInviteLinkDomainRestrictionVariables) -> DeleteInviteLinkDomainRestriction;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct DeleteInviteLinkDomainRestrictionOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum DeleteInviteLinkDomainRestrictionResult {
+    DeleteInviteLinkDomainRestrictionOutput(DeleteInviteLinkDomainRestrictionOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct DeleteInviteLinkDomainRestrictionInput {
+    pub team_uid: cynic::Id,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/delete_managed_secret.rs

@@ -0,0 +1,43 @@
+use crate::{
+    error::UserFacingError, object_permissions::Owner, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct DeleteManagedSecretVariables {
+    pub input: DeleteManagedSecretInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "DeleteManagedSecretVariables"
+)]
+pub struct DeleteManagedSecret {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub delete_managed_secret: DeleteManagedSecretResult,
+}
+
+crate::client::define_operation! {
+    delete_managed_secret(DeleteManagedSecretVariables) -> DeleteManagedSecret;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct DeleteManagedSecretOutput {
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum DeleteManagedSecretResult {
+    DeleteManagedSecretOutput(DeleteManagedSecretOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct DeleteManagedSecretInput {
+    pub name: String,
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/delete_object.rs

@@ -0,0 +1,40 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct DeleteObjectVariables {
+    pub input: DeleteObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "DeleteObjectVariables")]
+pub struct DeleteObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub delete_object: DeleteObjectResult,
+}
+crate::client::define_operation! {
+    delete_object(DeleteObjectVariables) -> DeleteObject;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct DeleteObjectOutput {
+    pub deleted_uids: Vec<cynic::Id>,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum DeleteObjectResult {
+    DeleteObjectOutput(DeleteObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct DeleteObjectInput {
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/delete_team_invite.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation DeleteTeamInvite(
+  $input: DeleteTeamInviteInput!,
+  $requestContext: RequestContext!
+) {
+  deleteTeamInvite(input:$input, requestContext: $requestContext) {
+    ... on DeleteTeamInviteOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct DeleteTeamInviteVariables {
+    pub input: DeleteTeamInviteInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "DeleteTeamInviteVariables")]
+pub struct DeleteTeamInvite {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub delete_team_invite: DeleteTeamInviteResult,
+}
+crate::client::define_operation! {
+    delete_team_invite(DeleteTeamInviteVariables) -> DeleteTeamInvite;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct DeleteTeamInviteOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum DeleteTeamInviteResult {
+    DeleteTeamInviteOutput(DeleteTeamInviteOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct DeleteTeamInviteInput {
+    pub email: String,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/empty_trash.rs

@@ -0,0 +1,61 @@
+use crate::{
+    error::UserFacingError, object_permissions::Owner, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+/*
+mutation EmptyTrash($input: EmptyTrashInput!, $requestContext: RequestContext!) {
+  emptyTrash(input: $input, requestContext: $requestContext) {
+    ... on EmptyTrashOutput {
+      deletedUids
+      responseContext {
+        serverVersion
+      }
+      success
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct EmptyTrashVariables {
+    pub input: EmptyTrashInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "EmptyTrashVariables")]
+pub struct EmptyTrash {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub empty_trash: EmptyTrashResult,
+}
+crate::client::define_operation! {
+    empty_trash(EmptyTrashVariables) -> EmptyTrash;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct EmptyTrashOutput {
+    pub deleted_uids: Vec<cynic::Id>,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+#[derive(cynic::InlineFragments, Debug)]
+pub enum EmptyTrashResult {
+    EmptyTrashOutput(EmptyTrashOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct EmptyTrashInput {
+    pub owner: Owner,
+}

crates/graphql/src/api/mutations/expire_api_key.rs

@@ -0,0 +1,32 @@
+use crate::{error::UserFacingError, request_context::RequestContext, schema};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ExpireApiKeyVariables {
+    pub key_uid: cynic::Id,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "ExpireApiKeyVariables")]
+pub struct ExpireApiKey {
+    #[arguments(input: { keyUID: $key_uid }, requestContext: $request_context)]
+    pub expire_api_key: ExpireApiKeyResult,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct ExpireApiKeyOutput {
+    pub __typename: String,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum ExpireApiKeyResult {
+    ExpireApiKeyOutput(ExpireApiKeyOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+crate::client::define_operation! {
+    expire_api_key(ExpireApiKeyVariables) -> ExpireApiKey;
+}

crates/graphql/src/api/mutations/generate_api_key.rs

@@ -0,0 +1,46 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+use crate::queries::api_keys::ApiKeyProperties;
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GenerateApiKeyVariables {
+    pub input: GenerateApiKeyInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct GenerateApiKeyInput {
+    pub name: String,
+    pub team_id: Option<cynic::Id>,
+    pub expires_at: Option<Time>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateApiKeyOutput {
+    pub raw_api_key: String,
+    pub api_key: ApiKeyProperties,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateApiKeyResult {
+    GenerateApiKeyOutput(GenerateApiKeyOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "GenerateApiKeyVariables")]
+pub struct GenerateApiKey {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub generate_api_key: GenerateApiKeyResult,
+}
+
+crate::client::define_operation! {
+    generate_api_key(GenerateApiKeyVariables) -> GenerateApiKey;
+}

crates/graphql/src/api/mutations/generate_code_embeddings.rs

@@ -0,0 +1,66 @@
+use crate::{
+    error::UserFacingError,
+    full_source_code_embedding::{ContentHash, EmbeddingConfig, Fragment, NodeHash, RepoMetadata},
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GenerateCodeEmbeddingsVariables {
+    pub input: GenerateCodeEmbeddingsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct GenerateCodeEmbeddingsInput {
+    pub embedding_config: EmbeddingConfig,
+    pub repo_metadata: RepoMetadata,
+    pub fragments: Vec<Fragment>,
+    pub root_hash: NodeHash,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct MerkleTreeNode {
+    pub hash: NodeHash,
+    pub children: Vec<NodeHash>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "GenerateCodeEmbeddingsVariables"
+)]
+pub struct GenerateCodeEmbeddings {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub generate_code_embeddings: GenerateCodeEmbeddingsResult,
+}
+crate::client::define_operation! {
+    generate_code_embeddings(GenerateCodeEmbeddingsVariables) -> GenerateCodeEmbeddings;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCodeEmbeddingsError {
+    pub error: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCodeEmbeddingsOutput {
+    pub response_context: ResponseContext,
+    pub embedding_results: Vec<GenerateCodeEmbeddingResult>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCodeEmbeddingResult {
+    pub hash: ContentHash,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateCodeEmbeddingsResult {
+    GenerateCodeEmbeddingsOutput(GenerateCodeEmbeddingsOutput),
+    GenerateCodeEmbeddingsError(GenerateCodeEmbeddingsError),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/generate_commands.rs

@@ -0,0 +1,114 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation GenerateCommands($input: GenerateCommandsInput!, $requestContext: RequestContext!) {
+  generateCommands(input: $input, requestContext: $requestContext) {
+    ... on GenerateCommandsOutput {
+      status {
+        ... on GenerateCommandsSuccess {
+          commands {
+            command
+            description
+            parameters {
+              description
+              id
+            }
+          }
+        }
+        ... on GenerateCommandsFailure {
+          type
+        }
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GenerateCommandsVariables {
+    pub input: GenerateCommandsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "GenerateCommandsVariables")]
+pub struct GenerateCommands {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub generate_commands: GenerateCommandsResult,
+}
+crate::client::define_operation! {
+    generate_commands(GenerateCommandsVariables) -> GenerateCommands;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCommandsSuccess {
+    pub commands: Vec<GeneratedCommand>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GeneratedCommand {
+    pub command: String,
+    pub description: String,
+    pub parameters: Vec<GeneratedCommandParameter>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GeneratedCommandParameter {
+    pub description: String,
+    pub id: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCommandsOutput {
+    pub status: GenerateCommandsStatus,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateCommandsFailure {
+    #[cynic(rename = "type")]
+    pub type_: GenerateCommandsFailureType,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateCommandsResult {
+    GenerateCommandsOutput(GenerateCommandsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateCommandsStatus {
+    GenerateCommandsSuccess(GenerateCommandsSuccess),
+    GenerateCommandsFailure(GenerateCommandsFailure),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum GenerateCommandsFailureType {
+    AiProviderError,
+    BadPrompt,
+    Other,
+    RateLimited,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct GenerateCommandsInput {
+    pub prompt: String,
+}

crates/graphql/src/api/mutations/generate_dialogue.rs

@@ -0,0 +1,108 @@
+use crate::{
+    ai::RequestLimitInfo, error::UserFacingError, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+/*
+mutation GenerateDialogue($input: GenerateDialogueInput!, $requestContext: RequestContext!) {
+  generateDialogue(input: $input, requestContext: $requestContext) {
+    ... on GenerateDialogueOutput {
+      status {
+        ... on GenerateDialogueSuccess {
+          answer
+          requestLimitInfo {
+            isUnlimited
+            nextRefreshTime
+            requestLimit
+            requestsUsedSinceLastRefresh
+          }
+          transcriptSummarized
+          truncated
+        }
+        ... on GenerateDialogueFailure {
+          requestLimitInfo {
+            isUnlimited
+            nextRefreshTime
+            requestLimit
+            requestsUsedSinceLastRefresh
+          }
+        }
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GenerateDialogueVariables {
+    pub input: GenerateDialogueInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "GenerateDialogueVariables")]
+pub struct GenerateDialogue {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub generate_dialogue: GenerateDialogueResult,
+}
+crate::client::define_operation! {
+    generate_dialogue(GenerateDialogueVariables) -> GenerateDialogue;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateDialogueSuccess {
+    pub answer: String,
+    pub request_limit_info: RequestLimitInfo,
+    pub transcript_summarized: bool,
+    pub truncated: bool,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateDialogueOutput {
+    pub status: GenerateDialogueStatus,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateDialogueFailure {
+    pub request_limit_info: RequestLimitInfo,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateDialogueResult {
+    GenerateDialogueOutput(GenerateDialogueOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateDialogueStatus {
+    GenerateDialogueSuccess(GenerateDialogueSuccess),
+    GenerateDialogueFailure(GenerateDialogueFailure),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct GenerateDialogueInput {
+    pub prompt: String,
+    pub transcript: Vec<TranscriptPart>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TranscriptPart {
+    pub assistant: String,
+    pub user: String,
+}

crates/graphql/src/api/mutations/generate_metadata_for_command.rs

@@ -0,0 +1,114 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation GenerateMetadataForCommand($input: GenerateMetadataForCommandInput!, $requestContext: RequestContext!) {
+  generateMetadataForCommand(input: $input, requestContext: $requestContext) {
+    ... on GenerateMetadataForCommandOutput {
+      responseContext {
+        serverVersion
+      }
+      status {
+        ... on GenerateMetadataForCommandSuccess {
+          description
+          parameterizedCommand
+          parameters {
+            description
+            name
+            value
+          }
+          title
+        }
+        ... on GenerateMetadataForCommandFailure {
+          type
+        }
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GenerateMetadataForCommandVariables {
+    pub input: GenerateMetadataForCommandInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "GenerateMetadataForCommandVariables"
+)]
+pub struct GenerateMetadataForCommand {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub generate_metadata_for_command: GenerateMetadataForCommandResult,
+}
+crate::client::define_operation! {
+    generate_metadata_for_command(GenerateMetadataForCommandVariables) -> GenerateMetadataForCommand;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateMetadataForCommandSuccess {
+    pub description: String,
+    pub parameterized_command: String,
+    pub parameters: Vec<GeneratedMetadataForCommand>,
+    pub title: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GeneratedMetadataForCommand {
+    pub description: String,
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateMetadataForCommandOutput {
+    pub response_context: ResponseContext,
+    pub status: GenerateMetadataForCommandStatus,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenerateMetadataForCommandFailure {
+    #[cynic(rename = "type")]
+    pub type_: GenerateMetadataForCommandFailureType,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateMetadataForCommandResult {
+    GenerateMetadataForCommandOutput(GenerateMetadataForCommandOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum GenerateMetadataForCommandStatus {
+    GenerateMetadataForCommandSuccess(GenerateMetadataForCommandSuccess),
+    GenerateMetadataForCommandFailure(GenerateMetadataForCommandFailure),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum GenerateMetadataForCommandFailureType {
+    AiProviderError,
+    BadCommand,
+    Other,
+    RateLimited,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct GenerateMetadataForCommandInput {
+    pub command: String,
+}

crates/graphql/src/api/mutations/give_up_notebook_edit_access.rs

@@ -0,0 +1,24 @@
+use crate::{
+    notebook::{UpdateNotebookEditAccessInput, UpdateNotebookEditAccessResult},
+    request_context::RequestContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GiveUpNotebookEditAccessVariables {
+    pub input: UpdateNotebookEditAccessInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "GiveUpNotebookEditAccessVariables"
+)]
+pub struct GiveUpNotebookEditAccess {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub give_up_notebook_edit_access: UpdateNotebookEditAccessResult,
+}
+crate::client::define_operation! {
+    give_up_notebook_edit_access(GiveUpNotebookEditAccessVariables) -> GiveUpNotebookEditAccess;
+}

crates/graphql/src/api/mutations/grab_notebook_edit_access.rs

@@ -0,0 +1,24 @@
+use crate::{
+    notebook::{UpdateNotebookEditAccessInput, UpdateNotebookEditAccessResult},
+    request_context::RequestContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct GrabNotebookEditAccessVariables {
+    pub input: UpdateNotebookEditAccessInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "GrabNotebookEditAccessVariables"
+)]
+pub struct GrabNotebookEditAccess {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub grab_notebook_edit_access: UpdateNotebookEditAccessResult,
+}
+crate::client::define_operation! {
+    grab_notebook_edit_access(GrabNotebookEditAccessVariables) -> GrabNotebookEditAccess;
+}

crates/graphql/src/api/mutations/issue_task_identity_token.rs

@@ -0,0 +1,47 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    scalars::Time, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct IssueTaskIdentityTokenVariables {
+    pub input: IssueTaskIdentityTokenInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "IssueTaskIdentityTokenVariables"
+)]
+pub struct IssueTaskIdentityToken {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub issue_task_identity_token: IssueTaskIdentityTokenResult,
+}
+
+crate::client::define_operation! {
+    issue_task_identity_token(IssueTaskIdentityTokenVariables) -> IssueTaskIdentityToken;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum IssueTaskIdentityTokenResult {
+    IssueTaskIdentityTokenOutput(IssueTaskIdentityTokenOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct IssueTaskIdentityTokenOutput {
+    pub token: String,
+    pub expires_at: Time,
+    pub issuer: String,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct IssueTaskIdentityTokenInput {
+    pub audience: String,
+    pub requested_duration_seconds: i32,
+    pub subject_template: Option<Vec<String>>,
+}

crates/graphql/src/api/mutations/join_team_with_team_discovery.rs

@@ -0,0 +1,72 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation JoinTeamWithTeamDiscovery($input: JoinTeamWithTeamDiscoveryInput!, $requestContext: RequestContext!) {
+  joinTeamWithTeamDiscovery(input: $input, requestContext: $requestContext) {
+    ... on JoinTeamWithTeamDiscoveryOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct JoinTeamWithTeamDiscoveryVariables {
+    pub input: JoinTeamWithTeamDiscoveryInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "JoinTeamWithTeamDiscoveryVariables"
+)]
+pub struct JoinTeamWithTeamDiscovery {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub join_team_with_team_discovery: JoinTeamWithTeamDiscoveryResult,
+}
+crate::client::define_operation! {
+    join_team_with_team_discovery(JoinTeamWithTeamDiscoveryVariables) -> JoinTeamWithTeamDiscovery;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct JoinTeamWithTeamDiscoveryOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum JoinTeamWithTeamDiscoveryResult {
+    JoinTeamWithTeamDiscoveryOutput(JoinTeamWithTeamDiscoveryOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum TeamDiscoveryEntrypoint {
+    #[cynic(rename = "TeamSettings")]
+    TeamSettings,
+    #[cynic(rename = "WebSignup")]
+    WebSignup,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct JoinTeamWithTeamDiscoveryInput {
+    pub entrypoint: TeamDiscoveryEntrypoint,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/leave_object.rs

@@ -0,0 +1,35 @@
+use crate::{error::UserFacingError, request_context::RequestContext, schema};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct LeaveObjectVariables {
+    pub input: LeaveObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "LeaveObjectVariables")]
+pub struct LeaveObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub leave_object: LeaveObjectResult,
+}
+crate::client::define_operation! {
+    leave_object(LeaveObjectVariables) -> LeaveObject;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct LeaveObjectOutput {
+    pub object_uid: cynic::Id,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum LeaveObjectResult {
+    LeaveObjectOutput(LeaveObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct LeaveObjectInput {
+    pub object_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/mint_custom_token.rs

@@ -0,0 +1,33 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct MintCustomTokenVariables {
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "MintCustomTokenVariables")]
+pub struct MintCustomToken {
+    #[arguments(requestContext: $request_context)]
+    pub mint_custom_token: MintCustomTokenResult,
+}
+crate::client::define_operation! {
+    mint_custom_token(MintCustomTokenVariables) -> MintCustomToken;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct MintCustomTokenOutput {
+    pub custom_token: String,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum MintCustomTokenResult {
+    MintCustomTokenOutput(MintCustomTokenOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/mod.rs

@@ -0,0 +1,69 @@
+pub mod add_invite_link_domain_restriction;
+pub mod add_object_guests;
+pub mod bulk_create_objects;
+pub mod confirm_file_artifact_upload;
+pub mod create_agent_task;
+pub mod create_anonymous_user;
+pub mod create_file_artifact_upload_target;
+pub mod create_folder;
+pub mod create_generic_string_object;
+pub mod create_managed_secret;
+pub mod create_notebook;
+pub mod create_simple_integration;
+pub mod create_team;
+pub mod create_workflow;
+pub mod delete_ai_conversation;
+pub mod delete_invite_link_domain_restriction;
+pub mod delete_managed_secret;
+pub mod delete_object;
+pub mod delete_team_invite;
+pub mod empty_trash;
+pub mod expire_api_key;
+pub mod generate_api_key;
+pub mod generate_code_embeddings;
+pub mod generate_commands;
+pub mod generate_dialogue;
+pub mod generate_metadata_for_command;
+pub mod give_up_notebook_edit_access;
+pub mod grab_notebook_edit_access;
+pub mod issue_task_identity_token;
+pub mod join_team_with_team_discovery;
+pub mod leave_object;
+pub mod mint_custom_token;
+pub mod move_object;
+pub mod populate_merkle_tree_cache;
+pub mod purchase_addon_credits;
+pub mod record_object_action;
+pub mod remove_object_guest;
+pub mod remove_object_link_permissions;
+pub mod remove_user_from_team;
+pub mod rename_team;
+pub mod request_bonus;
+pub mod reset_invite_links;
+pub mod send_referral_invite_emails;
+pub mod send_team_invite_email;
+pub mod set_is_invite_link_enabled;
+pub mod set_object_link_permissions;
+pub mod set_team_discoverability;
+pub mod set_team_member_role;
+pub mod set_user_is_onboarded;
+pub mod share_block;
+pub mod stripe_billing_portal;
+pub mod transfer_generic_string_object_owner;
+pub mod transfer_notebook_owner;
+pub mod transfer_team_ownership;
+pub mod transfer_workflow_owner;
+pub mod trash_object;
+pub mod unshare_block;
+pub mod untrash_object;
+pub mod update_agent_task;
+pub mod update_folder;
+pub mod update_generic_string_object;
+pub mod update_managed_secret;
+pub mod update_merkle_tree;
+pub mod update_notebook;
+pub mod update_object_guests;
+pub mod update_onboarding_survey_status;
+pub mod update_user_settings;
+pub mod update_workflow;
+pub mod update_workspace_settings;

crates/graphql/src/api/mutations/move_object.rs

@@ -0,0 +1,47 @@
+use crate::{
+    error::UserFacingError,
+    object::{ObjectMetadata, ObjectType},
+    object_permissions::Owner,
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct MoveObjectVariables {
+    pub input: MoveObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "MoveObjectVariables")]
+pub struct MoveObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub move_object: MoveObjectResult,
+}
+crate::client::define_operation! {
+    move_object(MoveObjectVariables) -> MoveObject;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct MoveObjectOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+    pub metadata: ObjectMetadata,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum MoveObjectResult {
+    MoveObjectOutput(MoveObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct MoveObjectInput {
+    pub new_folder_uid: Option<cynic::Id>,
+    pub new_owner: Owner,
+    pub object_type: ObjectType,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/populate_merkle_tree_cache.rs

@@ -0,0 +1,40 @@
+use crate::{
+    error::UserFacingError,
+    full_source_code_embedding::{EmbeddingConfig, NodeHash, RepoMetadata},
+    request_context::RequestContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct PopulateMerkleTreeCacheVariables {
+    pub embedding_config: EmbeddingConfig,
+    pub root_hash: NodeHash,
+    pub repo_metadata: RepoMetadata,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "PopulateMerkleTreeCacheVariables"
+)]
+pub struct PopulateMerkleTreeCache {
+    #[arguments(input: { embeddingConfig: $embedding_config, rootHash: $root_hash, repoMetadata: $repo_metadata }, requestContext: $request_context)]
+    pub populate_merkle_tree_cache: PopulateMerkleTreeCacheResult,
+}
+crate::client::define_operation! {
+    populate_merkle_tree_cache(PopulateMerkleTreeCacheVariables) -> PopulateMerkleTreeCache;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct PopulateMerkleTreeCacheOutput {
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum PopulateMerkleTreeCacheResult {
+    UserFacingError(UserFacingError),
+    PopulateMerkleTreeCacheOutput(PopulateMerkleTreeCacheOutput),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/purchase_addon_credits.rs

@@ -0,0 +1,43 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::InputObject, Debug)]
+pub struct PurchaseAddonCreditsInput {
+    pub credits: i32,
+    pub team_uid: cynic::Id,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct PurchaseAddonCreditsVariables {
+    pub input: PurchaseAddonCreditsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "PurchaseAddonCreditsVariables"
+)]
+pub struct PurchaseAddonCredits {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub purchase_addon_credits: PurchaseAddonCreditsResult,
+}
+crate::client::define_operation! {
+    purchase_addon_credits(PurchaseAddonCreditsVariables) -> PurchaseAddonCredits;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum PurchaseAddonCreditsResult {
+    PurchaseAddonCreditsOutput(PurchaseAddonCreditsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct PurchaseAddonCreditsOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}

crates/graphql/src/api/mutations/record_object_action.rs

@@ -0,0 +1,89 @@
+use crate::{
+    error::UserFacingError,
+    object_actions::{ActionType, ObjectActionHistory},
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    scalars::Time,
+    schema,
+};
+
+/*
+mutation RecordObjectAction($input: RecordObjectActionInput!, $requestContext: RequestContext!) {
+  recordObjectAction(input: $input, requestContext: $requestContext) {
+    ... on RecordObjectActionOutput {
+      history {
+        actions {
+          ... on BundledActions {
+            actionType
+            count
+            latestProcessedAtTimestamp
+            latestTimestamp
+            oldestTimestamp
+          }
+          ... on SingleAction {
+            actionType
+            processedAtTimestamp
+            timestamp
+          }
+        }
+        latestProcessedAtTimestamp
+        latestTimestamp
+        objectType
+        uid
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct RecordObjectActionVariables {
+    pub input: RecordObjectActionInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "RecordObjectActionVariables"
+)]
+pub struct RecordObjectAction {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub record_object_action: RecordObjectActionResult,
+}
+crate::client::define_operation! {
+    record_object_action(RecordObjectActionVariables) -> RecordObjectAction;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RecordObjectActionOutput {
+    pub history: ObjectActionHistory,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RecordObjectActionResult {
+    RecordObjectActionOutput(RecordObjectActionOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RecordObjectActionInput {
+    pub action: ActionType,
+    pub json_data: Option<String>,
+    pub timestamp: Time,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/remove_object_guest.rs

@@ -0,0 +1,46 @@
+use crate::{
+    error::UserFacingError, object_permissions::ObjectPermissions, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct RemoveObjectGuestVariables {
+    pub input: RemoveObjectGuestInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "RemoveObjectGuestVariables"
+)]
+pub struct RemoveObjectGuest {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub remove_object_guest: RemoveObjectGuestResult,
+}
+crate::client::define_operation! {
+    remove_object_guest(RemoveObjectGuestVariables) -> RemoveObjectGuest;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RemoveObjectGuestOutput {
+    pub object_permissions: ObjectPermissions,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RemoveObjectGuestResult {
+    RemoveObjectGuestOutput(RemoveObjectGuestOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RemoveObjectGuestInput {
+    /// Email of the user or pending user to remove. One of email or team_uid must be provided.
+    pub email: Option<String>,
+    pub object_uid: cynic::Id,
+    /// UID of the team to remove. One of email or team_uid must be provided.
+    pub team_uid: Option<cynic::Id>,
+}

crates/graphql/src/api/mutations/remove_object_link_permissions.rs

@@ -0,0 +1,42 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct RemoveObjectLinkPermissionsVariables {
+    pub input: RemoveObjectLinkPermissionsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "RemoveObjectLinkPermissionsVariables"
+)]
+pub struct RemoveObjectLinkPermissions {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub remove_object_link_permissions: RemoveObjectLinkPermissionsResult,
+}
+crate::client::define_operation! {
+    remove_object_link_permissions(RemoveObjectLinkPermissionsVariables) -> RemoveObjectLinkPermissions;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RemoveObjectLinkPermissionsOutput {
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RemoveObjectLinkPermissionsResult {
+    RemoveObjectLinkPermissionsOutput(RemoveObjectLinkPermissionsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RemoveObjectLinkPermissionsInput {
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/remove_user_from_team.rs

@@ -0,0 +1,65 @@
+use crate::{
+    error::UserFacingError, object::CloudObjectEventEntrypoint, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+/*
+mutation RemoveUserFromTeam($input: RemoveUserFromTeamInput!, $requestContext: RequestContext!) {
+  removeUserFromTeam(input: $input, requestContext: $requestContext) {
+    ... on RemoveUserFromTeamOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct RemoveUserFromTeamVariables {
+    pub input: RemoveUserFromTeamInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "RemoveUserFromTeamVariables"
+)]
+pub struct RemoveUserFromTeam {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub remove_user_from_team: RemoveUserFromTeamResult,
+}
+crate::client::define_operation! {
+    remove_user_from_team(RemoveUserFromTeamVariables) -> RemoveUserFromTeam;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RemoveUserFromTeamOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RemoveUserFromTeamResult {
+    RemoveUserFromTeamOutput(RemoveUserFromTeamOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RemoveUserFromTeamInput {
+    pub entrypoint: CloudObjectEventEntrypoint,
+    pub team_uid: cynic::Id,
+    pub user_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/rename_team.rs

@@ -0,0 +1,61 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation RenameTeam($input: RenameTeamInput!, $requestContext: RequestContext!) {
+  renameTeam(input: $input, requestContext: $requestContext) {
+    ... on RenameTeamOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct RenameTeamVariables {
+    pub input: RenameTeamInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "RenameTeamVariables")]
+pub struct RenameTeam {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub rename_team: RenameTeamResult,
+}
+crate::client::define_operation! {
+    rename_team(RenameTeamVariables) -> RenameTeam;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RenameTeamOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RenameTeamResult {
+    RenameTeamOutput(RenameTeamOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RenameTeamInput {
+    pub new_name: String,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/request_bonus.rs

@@ -0,0 +1,65 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation ProvideNegativeFeedbackResponseForAiConversation
+($input: ProvideNegativeFeedbackResponseForAiConversationInput!, $requestContext: RequestContext!) {
+  provideNegativeFeedbackResponseForAiConversation(input: $input, requestContext: $requestContext) {
+    ... on RequestsRefundedOutput {
+      requestsRefunded
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+ */
+
+#[derive(cynic::InputObject, Debug)]
+pub struct ProvideNegativeFeedbackResponseForAiConversationInput {
+    pub conversation_id: cynic::Id,
+    pub request_ids: Vec<cynic::Id>,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ProvideNegativeFeedbackResponseForAiConversationVariables {
+    pub input: ProvideNegativeFeedbackResponseForAiConversationInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "ProvideNegativeFeedbackResponseForAiConversationVariables"
+)]
+pub struct ProvideNegativeFeedbackResponseForAiConversation {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub provide_negative_feedback_response_for_ai_conversation: RequestsRefundedResult,
+}
+crate::client::define_operation! {
+    provide_negative_feedback_response_for_ai_conversation(ProvideNegativeFeedbackResponseForAiConversationVariables) -> ProvideNegativeFeedbackResponseForAiConversation;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum RequestsRefundedResult {
+    RequestsRefundedOutput(RequestsRefundedOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct RequestsRefundedOutput {
+    pub requests_refunded: i32,
+    pub response_context: ResponseContext,
+}

crates/graphql/src/api/mutations/reset_invite_links.rs

@@ -0,0 +1,60 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation ResetInviteLinks($input: ResetInviteLinksInput!, $requestContext: RequestContext!) {
+  resetInviteLinks(input: $input, requestContext: $requestContext) {
+    ... on ResetInviteLinksOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ResetInviteLinksVariables {
+    pub input: ResetInviteLinksInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "ResetInviteLinksVariables")]
+pub struct ResetInviteLinks {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub reset_invite_links: ResetInviteLinksResult,
+}
+crate::client::define_operation! {
+    reset_invite_links(ResetInviteLinksVariables) -> ResetInviteLinks;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct ResetInviteLinksOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum ResetInviteLinksResult {
+    ResetInviteLinksOutput(ResetInviteLinksOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct ResetInviteLinksInput {
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/send_referral_invite_emails.rs

@@ -0,0 +1,63 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation SendReferralInviteEmails($input: SendReferralInviteEmailsInput!, $requestContext: RequestContext!) {
+  sendReferralInviteEmails(input: $input, requestContext: $requestContext) {
+    ... on SendReferralInviteEmailsOutput {
+      responseContext {
+        serverVersion
+      }
+      successfulEmails
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SendReferralInviteEmailsVariables {
+    pub input: SendReferralInviteEmailsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SendReferralInviteEmailsInput {
+    pub emails: Vec<String>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SendReferralInviteEmailsVariables"
+)]
+pub struct SendReferralInviteEmails {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub send_referral_invite_emails: SendReferralInviteEmailsResult,
+}
+crate::client::define_operation! {
+    send_referral_invite_emails(SendReferralInviteEmailsVariables) -> SendReferralInviteEmails;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SendReferralInviteEmailsOutput {
+    pub successful_emails: Vec<String>,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SendReferralInviteEmailsResult {
+    SendReferralInviteEmailsOutput(SendReferralInviteEmailsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/send_team_invite_email.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation SendTeamInviteEmail($input: SendTeamInviteEmailInput!, $requestContext: RequestContext!) {
+  sendTeamInviteEmail(input: $input, requestContext: $requestContext) {
+    ... on SendTeamInviteEmailOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SendTeamInviteEmailVariables {
+    pub input: SendTeamInviteEmailInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SendTeamInviteEmailOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SendTeamInviteEmailVariables"
+)]
+pub struct SendTeamInviteEmail {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub send_team_invite_email: SendTeamInviteEmailResult,
+}
+crate::client::define_operation! {
+    send_team_invite_email(SendTeamInviteEmailVariables) -> SendTeamInviteEmail;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SendTeamInviteEmailResult {
+    SendTeamInviteEmailOutput(SendTeamInviteEmailOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SendTeamInviteEmailInput {
+    pub email: String,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/set_is_invite_link_enabled.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation SetIsInviteLinkEnabled($input: SetIsInviteLinkEnabledInput!, $requestContext: RequestContext!) {
+  setIsInviteLinkEnabled(input: $input, requestContext: $requestContext) {
+    ... on SetIsInviteLinkEnabledOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SetIsInviteLinkEnabledVariables {
+    pub input: SetIsInviteLinkEnabledInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SetIsInviteLinkEnabledOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SetIsInviteLinkEnabledVariables"
+)]
+pub struct SetIsInviteLinkEnabled {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub set_is_invite_link_enabled: SetIsInviteLinkEnabledResult,
+}
+crate::client::define_operation! {
+    set_is_invite_link_enabled(SetIsInviteLinkEnabledVariables) -> SetIsInviteLinkEnabled;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SetIsInviteLinkEnabledResult {
+    SetIsInviteLinkEnabledOutput(SetIsInviteLinkEnabledOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SetIsInviteLinkEnabledInput {
+    pub new_value: bool,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/set_object_link_permissions.rs

@@ -0,0 +1,42 @@
+use crate::{
+    error::UserFacingError, object_permissions::AccessLevel, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SetObjectLinkPermissionsVariables {
+    pub input: SetObjectLinkPermissionsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SetObjectLinkPermissionsOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SetObjectLinkPermissionsVariables"
+)]
+pub struct SetObjectLinkPermissions {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub set_object_link_permissions: SetObjectLinkPermissionsResult,
+}
+crate::client::define_operation! {
+    set_object_link_permissions(SetObjectLinkPermissionsVariables) -> SetObjectLinkPermissions;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SetObjectLinkPermissionsResult {
+    SetObjectLinkPermissionsOutput(SetObjectLinkPermissionsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+#[derive(cynic::InputObject, Debug)]
+pub struct SetObjectLinkPermissionsInput {
+    pub access_level: AccessLevel,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/set_team_discoverability.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation SetTeamDiscoverability($input: SetTeamDiscoverabilityInput!, $requestContext: RequestContext!) {
+  setTeamDiscoverability(input: $input, requestContext: $requestContext) {
+    ... on SetTeamDiscoverabilityOutput {
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SetTeamDiscoverabilityVariables {
+    pub input: SetTeamDiscoverabilityInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SetTeamDiscoverabilityOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SetTeamDiscoverabilityVariables"
+)]
+pub struct SetTeamDiscoverability {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub set_team_discoverability: SetTeamDiscoverabilityResult,
+}
+crate::client::define_operation! {
+    set_team_discoverability(SetTeamDiscoverabilityVariables) -> SetTeamDiscoverability;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SetTeamDiscoverabilityResult {
+    SetTeamDiscoverabilityOutput(SetTeamDiscoverabilityOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SetTeamDiscoverabilityInput {
+    pub discoverable: bool,
+    pub team_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/set_team_member_role.rs

@@ -0,0 +1,67 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema, workspace::MembershipRole,
+};
+
+/*
+mutation SetTeamMemberRole($input: SetTeamMemberRoleInput!, $requestContext: RequestContext!) {
+  setTeamMemberRole(input: $input, requestContext: $requestContext) {
+    ... on SetTeamMemberRoleOutput {
+      __typename
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      __typename
+      responseContext {
+        serverVersion
+      }
+      error {
+        message
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SetTeamMemberRoleInput {
+    pub role: MembershipRole,
+    pub team_uid: cynic::Id,
+    pub user_uid: cynic::Id,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SetTeamMemberRoleVariables {
+    pub input: SetTeamMemberRoleInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SetTeamMemberRoleOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SetTeamMemberRoleVariables"
+)]
+pub struct SetTeamMemberRole {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub set_team_member_role: SetTeamMemberRoleResult,
+}
+crate::client::define_operation! {
+    set_team_member_role(SetTeamMemberRoleVariables) -> SetTeamMemberRole;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SetTeamMemberRoleResult {
+    SetTeamMemberRoleOutput(SetTeamMemberRoleOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/set_user_is_onboarded.rs

@@ -0,0 +1,55 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation SetUserIsOnboarded($requestContext: RequestContext!) {
+  setUserIsOnboarded(requestContext: $requestContext) {
+    ... on SetUserIsOnboardedOutput {
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "SetUserIsOnboardedVariables"
+)]
+pub struct SetUserIsOnboarded {
+    #[arguments(requestContext: $request_context)]
+    pub set_user_is_onboarded: SetUserIsOnboardedResult,
+}
+crate::client::define_operation! {
+    set_user_is_onboarded(SetUserIsOnboardedVariables) -> SetUserIsOnboarded;
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct SetUserIsOnboardedVariables {
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct SetUserIsOnboardedOutput {
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum SetUserIsOnboardedResult {
+    SetUserIsOnboardedOutput(SetUserIsOnboardedOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/share_block.rs

@@ -0,0 +1,58 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ShareBlockVariables<'a> {
+    pub block: BlockInput<'a>,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct ShareBlockOutput {
+    pub url_ending: String,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "ShareBlockVariables")]
+pub struct ShareBlock {
+    #[arguments(input: { block: $block }, requestContext: $request_context)]
+    pub share_block: ShareBlockResult,
+}
+crate::client::define_operation! {
+    ['a] share_block(ShareBlockVariables<'a>) -> ShareBlock;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum ShareBlockResult {
+    ShareBlockOutput(ShareBlockOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Debug)]
+pub enum DisplaySetting {
+    Command,
+    CommandAndOutput,
+    Output,
+    #[cynic(fallback)]
+    Other(String),
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct BlockInput<'a> {
+    pub command: Option<&'a str>,
+    pub embed_display_setting: DisplaySetting,
+    pub output: Option<&'a str>,
+    pub show_prompt: bool,
+    pub stylized_command: Option<&'a str>,
+    pub stylized_output: Option<&'a str>,
+    pub stylized_prompt: Option<&'a str>,
+    pub stylized_prompt_and_command: Option<&'a str>,
+    pub time_started_term: Option<Time>,
+    pub title: Option<&'a str>,
+}

crates/graphql/src/api/mutations/stripe_billing_portal.rs

@@ -0,0 +1,63 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation stripeBillingPortal($input: StripeBillingPortalInput!, $requestContext: RequestContext!) {
+  stripeBillingPortal(input: $input, requestContext: $requestContext) {
+    ... on StripeBillingPortalOutput {
+      __typename
+      url
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      __typename
+      error
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct StripeBillingPortalVariables {
+    pub input: StripeBillingPortalInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct StripeBillingPortalInput {
+    pub team_uid: cynic::Id,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "StripeBillingPortalVariables"
+)]
+pub struct StripeBillingPortal {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub stripe_billing_portal: StripeBillingPortalResult,
+}
+crate::client::define_operation! {
+    stripe_billing_portal(StripeBillingPortalVariables) -> StripeBillingPortal;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct StripeBillingPortalOutput {
+    pub url: String,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum StripeBillingPortalResult {
+    StripeBillingPortalOutput(StripeBillingPortalOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/transfer_generic_string_object_owner.rs

@@ -0,0 +1,44 @@
+use crate::{
+    error::UserFacingError, object::ObjectMetadata, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TransferGenericStringObjectOwnerVariables {
+    pub input: TransferGenericStringObjectOwnerInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct TransferGenericStringObjectOwnerOutput {
+    pub metadata: ObjectMetadata,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "TransferGenericStringObjectOwnerVariables"
+)]
+pub struct TransferGenericStringObjectOwner {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub transfer_generic_string_object_owner: TransferGenericStringObjectOwnerResult,
+}
+crate::client::define_operation! {
+    transfer_generic_string_object_owner(TransferGenericStringObjectOwnerVariables) -> TransferGenericStringObjectOwner;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum TransferGenericStringObjectOwnerResult {
+    TransferGenericStringObjectOwnerOutput(TransferGenericStringObjectOwnerOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TransferGenericStringObjectOwnerInput {
+    pub owner: Owner,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/transfer_notebook_owner.rs

@@ -0,0 +1,44 @@
+use crate::{
+    error::UserFacingError, object::ObjectMetadata, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TransferNotebookOwnerVariables {
+    pub input: TransferNotebookOwnerInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct TransferNotebookOwnerOutput {
+    pub metadata: ObjectMetadata,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "TransferNotebookOwnerVariables"
+)]
+pub struct TransferNotebookOwner {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub transfer_notebook_owner: TransferNotebookOwnerResult,
+}
+crate::client::define_operation! {
+    transfer_notebook_owner(TransferNotebookOwnerVariables) -> TransferNotebookOwner;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum TransferNotebookOwnerResult {
+    TransferNotebookOwnerOutput(TransferNotebookOwnerOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TransferNotebookOwnerInput {
+    pub owner: Owner,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/transfer_team_ownership.rs

@@ -0,0 +1,65 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation TransferTeamOwnership($input: TransferTeamOwnershipInput!, $requestContext: RequestContext!) {
+  transferTeamOwnership(input: $input, requestContext: $requestContext) {
+    ... on TransferTeamOwnershipOutput {
+      __typename
+      success
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      __typename
+      responseContext {
+        serverVersion
+      }
+      error {
+        message
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TransferTeamOwnershipInput {
+    pub new_owner_email: String,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TransferTeamOwnershipVariables {
+    pub input: TransferTeamOwnershipInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct TransferTeamOwnershipOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "TransferTeamOwnershipVariables"
+)]
+pub struct TransferTeamOwnership {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub transfer_team_ownership: TransferTeamOwnershipResult,
+}
+crate::client::define_operation! {
+    transfer_team_ownership(TransferTeamOwnershipVariables) -> TransferTeamOwnership;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum TransferTeamOwnershipResult {
+    TransferTeamOwnershipOutput(TransferTeamOwnershipOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/transfer_workflow_owner.rs

@@ -0,0 +1,44 @@
+use crate::{
+    error::UserFacingError, object::ObjectMetadata, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TransferWorkflowOwnerVariables {
+    pub input: TransferWorkflowOwnerInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct TransferWorkflowOwnerOutput {
+    pub metadata: ObjectMetadata,
+    pub response_context: ResponseContext,
+    pub success: bool,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "TransferWorkflowOwnerVariables"
+)]
+pub struct TransferWorkflowOwner {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub transfer_workflow_owner: TransferWorkflowOwnerResult,
+}
+crate::client::define_operation! {
+    transfer_workflow_owner(TransferWorkflowOwnerVariables) -> TransferWorkflowOwner;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum TransferWorkflowOwnerResult {
+    TransferWorkflowOwnerOutput(TransferWorkflowOwnerOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TransferWorkflowOwnerInput {
+    pub owner: Owner,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/trash_object.rs

@@ -0,0 +1,39 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TrashObjectVariables {
+    pub input: TrashObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct TrashObjectOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "TrashObjectVariables")]
+pub struct TrashObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub trash_object: TrashObjectResult,
+}
+crate::client::define_operation! {
+    trash_object(TrashObjectVariables) -> TrashObject;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum TrashObjectResult {
+    TrashObjectOutput(TrashObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct TrashObjectInput {
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/unshare_block.rs

@@ -0,0 +1,39 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UnshareBlockVariables {
+    pub input: UnshareBlockInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UnshareBlockOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UnshareBlockVariables")]
+pub struct UnshareBlock {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub unshare_block: UnshareBlockResult,
+}
+crate::client::define_operation! {
+    unshare_block(UnshareBlockVariables) -> UnshareBlock;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UnshareBlockResult {
+    UnshareBlockOutput(UnshareBlockOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UnshareBlockInput {
+    pub block_uid: String,
+}

crates/graphql/src/api/mutations/untrash_object.rs

@@ -0,0 +1,40 @@
+use crate::{
+    error::UserFacingError, object::ObjectMetadata, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UntrashObjectVariables {
+    pub input: UntrashObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UntrashObjectOutput {
+    pub success: bool,
+    pub response_context: ResponseContext,
+    pub metadata: ObjectMetadata,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UntrashObjectVariables")]
+pub struct UntrashObject {
+    #[arguments(requestContext: $request_context, input: $input)]
+    pub untrash_object: UntrashObjectResult,
+}
+crate::client::define_operation! {
+    untrash_object(UntrashObjectVariables) -> UntrashObject;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UntrashObjectResult {
+    UntrashObjectOutput(UntrashObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UntrashObjectInput {
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_agent_task.rs

@@ -0,0 +1,60 @@
+use crate::{
+    ai::{AgentTaskState, PlatformErrorCode},
+    error::UserFacingError,
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateAgentTaskVariables {
+    pub input: UpdateAgentTaskInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateAgentTaskInput {
+    pub task_id: cynic::Id,
+
+    // Important: for our server-side changeset logic to work, any fields which we aren't trying to
+    // update must be omitted, NOT set to null.
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub task_state: Option<AgentTaskState>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<cynic::Id>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub conversation_id: Option<cynic::Id>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub status_message: Option<AgentTaskStatusMessageInput>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct AgentTaskStatusMessageInput {
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<PlatformErrorCode>,
+    pub message: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UpdateAgentTaskVariables")]
+pub struct UpdateAgentTask {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_agent_task: UpdateAgentTaskResult,
+}
+
+crate::client::define_operation! {
+    update_agent_task(UpdateAgentTaskVariables) -> UpdateAgentTask;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateAgentTaskResult {
+    UpdateAgentTaskOutput(UpdateAgentTaskOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateAgentTaskOutput {
+    pub response_context: ResponseContext,
+}

crates/graphql/src/api/mutations/update_folder.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, object::ObjectUpdateSuccess, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+/*
+mutation UpdateFolder($input: UpdateFolderInput!, $requestContext: RequestContext!) {
+  updateFolder(input: $input, requestContext: $requestContext) {
+    ... on UpdateFolderOutput {
+      responseContext {
+        serverVersion
+      }
+      update {
+        lastEditorUid
+        revisionTs
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateFolderVariables {
+    pub input: UpdateFolderInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateFolderOutput {
+    pub response_context: ResponseContext,
+    pub update: ObjectUpdateSuccess,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UpdateFolderVariables")]
+pub struct UpdateFolder {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_folder: UpdateFolderResult,
+}
+crate::client::define_operation! {
+    update_folder(UpdateFolderVariables) -> UpdateFolder;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateFolderResult {
+    UpdateFolderOutput(UpdateFolderOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateFolderInput {
+    pub name: String,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_generic_string_object.rs

@@ -0,0 +1,62 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, generic_string_object::GenericStringObject,
+    object::ObjectUpdateSuccess, request_context::RequestContext,
+    response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateGenericStringObjectVariables {
+    pub input: UpdateGenericStringObjectInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateGenericStringObjectOutput {
+    pub response_context: ResponseContext,
+    pub update: GenericStringObjectUpdate,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateGenericStringObjectVariables"
+)]
+pub struct UpdateGenericStringObject {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_generic_string_object: UpdateGenericStringObjectResult,
+}
+crate::client::define_operation! {
+    update_generic_string_object(UpdateGenericStringObjectVariables) -> UpdateGenericStringObject;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct GenericStringObjectUpdateRejected {
+    pub conflicting_generic_string_object: GenericStringObject,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum GenericStringObjectUpdate {
+    GenericStringObjectUpdateRejected(GenericStringObjectUpdateRejected),
+    ObjectUpdateSuccess(ObjectUpdateSuccess),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum UpdateGenericStringObjectResult {
+    UpdateGenericStringObjectOutput(UpdateGenericStringObjectOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateGenericStringObjectInput {
+    pub revision_ts: Option<Time>,
+    pub serialized_model: String,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_managed_secret.rs

@@ -0,0 +1,48 @@
+use crate::{
+    error::UserFacingError, managed_secrets::ManagedSecret, object_permissions::Owner,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateManagedSecretVariables {
+    pub input: UpdateManagedSecretInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateManagedSecretVariables"
+)]
+pub struct UpdateManagedSecret {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_managed_secret: UpdateManagedSecretResult,
+}
+
+crate::client::define_operation! {
+    update_managed_secret(UpdateManagedSecretVariables) -> UpdateManagedSecret;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateManagedSecretOutput {
+    pub managed_secret: ManagedSecret,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateManagedSecretResult {
+    UpdateManagedSecretOutput(UpdateManagedSecretOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateManagedSecretInput {
+    pub owner: Owner,
+    pub name: String,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub encrypted_value: Option<String>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}

crates/graphql/src/api/mutations/update_merkle_tree.rs

@@ -0,0 +1,61 @@
+use crate::{
+    error::UserFacingError,
+    full_source_code_embedding::{EmbeddingConfig, NodeHash},
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateMerkleTreeVariables {
+    pub input: UpdateMerkleTreeInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateMerkleTreeInput {
+    pub embedding_config: EmbeddingConfig,
+    pub nodes: Vec<MerkleTreeNode>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct MerkleTreeNode {
+    pub hash: NodeHash,
+    pub children: Vec<NodeHash>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UpdateMerkleTreeVariables")]
+pub struct UpdateMerkleTree {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_merkle_tree: UpdateMerkleTreeResult,
+}
+crate::client::define_operation! {
+    update_merkle_tree(UpdateMerkleTreeVariables) -> UpdateMerkleTree;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateMerkleTreeError {
+    pub error: String,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateMerkleTreeOutput {
+    pub response_context: ResponseContext,
+    pub results: Vec<UpdateMerkleTreeNodeResult>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateMerkleTreeNodeResult {
+    pub hash: NodeHash,
+    pub success: bool,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateMerkleTreeResult {
+    UpdateMerkleTreeOutput(UpdateMerkleTreeOutput),
+    UpdateMerkleTreeError(UpdateMerkleTreeError),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/update_notebook.rs

@@ -0,0 +1,59 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, notebook::Notebook, object::ObjectUpdateSuccess,
+    request_context::RequestContext, response_context::ResponseContext, schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateNotebookVariables {
+    pub input: UpdateNotebookInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateNotebookOutput {
+    pub response_context: ResponseContext,
+    pub update: NotebookUpdate,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UpdateNotebookVariables")]
+pub struct UpdateNotebook {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_notebook: UpdateNotebookResult,
+}
+crate::client::define_operation! {
+    update_notebook(UpdateNotebookVariables) -> UpdateNotebook;
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct NotebookUpdateRejected {
+    pub conflicting_notebook: Notebook,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum NotebookUpdate {
+    NotebookUpdateRejected(NotebookUpdateRejected),
+    ObjectUpdateSuccess(ObjectUpdateSuccess),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum UpdateNotebookResult {
+    UpdateNotebookOutput(UpdateNotebookOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateNotebookInput {
+    pub data: Option<String>,
+    pub revision_ts: Option<Time>,
+    pub title: Option<String>,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_object_guests.rs

@@ -0,0 +1,47 @@
+use crate::{
+    error::UserFacingError,
+    object_permissions::{AccessLevel, ObjectPermissions},
+    request_context::RequestContext,
+    response_context::ResponseContext,
+    schema,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateObjectGuestsVariables {
+    pub input: UpdateObjectGuestsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateObjectGuestsOutput {
+    pub object_permissions: ObjectPermissions,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateObjectGuestsVariables"
+)]
+pub struct UpdateObjectGuests {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_object_guests: UpdateObjectGuestsResult,
+}
+crate::client::define_operation! {
+    update_object_guests(UpdateObjectGuestsVariables) -> UpdateObjectGuests;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateObjectGuestsResult {
+    UpdateObjectGuestsOutput(UpdateObjectGuestsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateObjectGuestsInput {
+    pub access_level: AccessLevel,
+    pub emails: Option<Vec<String>>,
+    pub object_uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_onboarding_survey_status.rs

@@ -0,0 +1,128 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation updateOnboardingSurveyStatus($input: UpdateOnboardingSurveyStatusInput!, $clientContext: ClientContext!, $osContext: OSContext!) {
+  updateOnboardingSurveyStatus(
+    input: $input
+    requestContext: {clientContext: $clientContext, osContext: $osContext}
+  ) {
+    ... on UpdateOnboardingSurveyStatusOutput {
+      status
+
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+    }
+  }
+}
+
+*/
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateOnboardingSurveyStatusVariables {
+    pub input: UpdateOnboardingSurveyStatusInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateOnboardingSurveyStatusOutput {
+    pub status: OnboardingSurveyStatus,
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateOnboardingSurveyStatusVariables"
+)]
+pub struct UpdateOnboardingSurveyStatus {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_onboarding_survey_status: UpdateOnboardingSurveyStatusResult,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateOnboardingSurveyStatusResult {
+    UpdateOnboardingSurveyStatusOutput(UpdateOnboardingSurveyStatusOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum AcquisitionChannelSurveyResponse {
+    Friend,
+    Internet,
+    InTheWild,
+    Teammate,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum OnboardingSurveyStatus {
+    Completed,
+    Shown,
+    Skipped,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum RoleSurveyResponse {
+    BackendEngineer,
+    BusinessAnalyst,
+    Data,
+    DevopsSre,
+    EngineeringManager,
+    FrontendEngineer,
+    FullstackEngineer,
+    Marketer,
+    MobileEngineer,
+    Other,
+    ProductDesigner,
+    ProductManager,
+    SalesBusinessDev,
+    Student,
+}
+
+#[derive(cynic::Enum, Clone, Copy, Debug)]
+pub enum UsagePlanSurveyResponse {
+    AiCodeProduction,
+    AiPersonalProjects,
+    ExploringTool,
+    Other,
+    ReplaceTerminal,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateOnboardingSurveyStatusInput {
+    pub responses: Option<SurveyResponsesInput>,
+    pub status: OnboardingSurveyStatus,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct SurveyResponsesInput {
+    #[cynic(rename = "ACQUISITION_CHANNEL")]
+    pub acquisition_channel: Option<AcquisitionChannelQuestionResponseInput>,
+    #[cynic(rename = "ROLE")]
+    pub role: Option<RoleQuestionResponseInput>,
+    #[cynic(rename = "USAGE_PLAN")]
+    pub usage_plan: Option<UsagePlanQuestionResponseInput>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct AcquisitionChannelQuestionResponseInput {
+    pub answer: AcquisitionChannelSurveyResponse,
+    pub details: Option<String>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct RoleQuestionResponseInput {
+    pub answer: RoleSurveyResponse,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UsagePlanQuestionResponseInput {
+    pub answer: UsagePlanSurveyResponse,
+    pub details: Option<String>,
+}

crates/graphql/src/api/mutations/update_user_settings.rs

@@ -0,0 +1,64 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema,
+};
+
+/*
+mutation UpdateUserSettings($input: UpdateUserSettingsInput!, $requestContext: RequestContext!) {
+  updateUserSettings(input: $input, requestContext: $requestContext) {
+    ... on UpdateUserSettingsOutput {
+      responseContext {
+        serverVersion
+      }
+    }
+    ... on UserFacingError {
+      error {
+        message
+      }
+      responseContext {
+        serverVersion
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateUserSettingsVariables"
+)]
+pub struct UpdateUserSettings {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_user_settings: UpdateUserSettingsResult,
+}
+
+crate::client::define_operation! {
+    update_user_settings(UpdateUserSettingsVariables) -> UpdateUserSettings;
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateUserSettingsVariables {
+    pub input: UpdateUserSettingsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug, Default)]
+pub struct UpdateUserSettingsInput {
+    pub cloud_conversation_storage_enabled: Option<bool>,
+    pub crash_reporting_enabled: Option<bool>,
+    pub telemetry_enabled: Option<bool>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateUserSettingsOutput {
+    pub response_context: ResponseContext,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateUserSettingsResult {
+    UpdateUserSettingsOutput(UpdateUserSettingsOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}

crates/graphql/src/api/mutations/update_workflow.rs

@@ -0,0 +1,58 @@
+use crate::scalars::Time;
+use crate::{
+    error::UserFacingError, object::ObjectUpdateSuccess, request_context::RequestContext,
+    response_context::ResponseContext, schema, workflow::Workflow,
+};
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateWorkflowVariables {
+    pub input: UpdateWorkflowInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct WorkflowUpdateRejected {
+    pub conflicting_workflow: Workflow,
+    pub revision_ts: Time,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateWorkflowOutput {
+    pub response_context: ResponseContext,
+    pub update: WorkflowUpdate,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "RootMutation", variables = "UpdateWorkflowVariables")]
+pub struct UpdateWorkflow {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_workflow: UpdateWorkflowResult,
+}
+crate::client::define_operation! {
+    update_workflow(UpdateWorkflowVariables) -> UpdateWorkflow;
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum UpdateWorkflowResult {
+    UpdateWorkflowOutput(UpdateWorkflowOutput),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum WorkflowUpdate {
+    ObjectUpdateSuccess(ObjectUpdateSuccess),
+    WorkflowUpdateRejected(WorkflowUpdateRejected),
+    #[cynic(fallback)]
+    Unknown,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateWorkflowInput {
+    pub data: String,
+    pub revision_ts: Option<Time>,
+    pub uid: cynic::Id,
+}

crates/graphql/src/api/mutations/update_workspace_settings.rs

@@ -0,0 +1,115 @@
+use crate::{
+    error::UserFacingError, request_context::RequestContext, response_context::ResponseContext,
+    schema, workspace::WorkspaceSettings,
+};
+
+// Note that `isInviteLinkEnabled` and `IsDiscoverable` aren't fetchable from this mutation;
+// they don't come from the same code path as fetching org settings. We could change this
+// but it's not something the server will populate at the moment.
+
+/*
+mutation UpdateWorkspaceSettings($input: UpdateWorkspaceSettingsInput!, $requestContext: RequestContext!) {
+  updateWorkspaceSettings(requestContext: $requestContext, input: $input) {
+    ... on UpdateWorkspaceSettingsOutput {
+      workspaceSettings {
+        llmSettings {
+          enabled
+        }
+        telemetrySettings {
+          forceEnabled
+        }
+        ugcCollectionSettings {
+          setting
+        }
+        linkSharingSettings {
+          anyoneWithLinkSharingEnabled
+          directLinkSharingEnabled
+        }
+        secretRedactionSettings {
+          enabled
+          regexList
+        }
+        aiPermissionsSettings {
+          allowAiInRemoteSessions
+          remoteSessionRegexList
+        }
+        aiAutonomySettings {
+          applyCodeDiffsSetting
+          readFilesSetting
+          readFilesAllowlist
+          createPlansSetting
+          executeCommandsSetting
+          executeCommandsAllowlist
+          executeCommandsDenylist
+          writeToPtySetting
+        }
+        usageBasedPricingSettings {
+          enabled
+          maxMonthlySpendCents
+        }
+        addonCreditsSettings {
+          autoReloadEnabled
+          maxMonthlySpendCents
+          selectedAutoReloadCreditDenomination
+        }
+        codebaseContextSettings {
+          enabled
+        }
+      }
+    }
+  }
+}
+*/
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(
+    graphql_type = "RootMutation",
+    variables = "UpdateWorkspaceSettingsVariables"
+)]
+pub struct UpdateWorkspaceSettings {
+    #[arguments(input: $input, requestContext: $request_context)]
+    pub update_workspace_settings: UpdateWorkspaceSettingsResult,
+}
+crate::client::define_operation! {
+    update_workspace_settings(UpdateWorkspaceSettingsVariables) -> UpdateWorkspaceSettings;
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct UpdateWorkspaceSettingsVariables {
+    pub input: UpdateWorkspaceSettingsInput,
+    pub request_context: RequestContext,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UpdateWorkspaceSettingsInput {
+    pub workspace_uid: String,
+    pub set_usage_based_pricing_settings: Option<UsageBasedPricingSettingsInput>,
+    pub set_addon_credits_settings: Option<AddonCreditsSettingsInput>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct UsageBasedPricingSettingsInput {
+    pub enabled: Option<bool>,
+    pub max_monthly_spend_cents: Option<i32>,
+}
+
+#[derive(cynic::InputObject, Debug)]
+pub struct AddonCreditsSettingsInput {
+    pub auto_reload_enabled: Option<bool>,
+    pub max_monthly_spend_cents: Option<i32>,
+    pub selected_auto_reload_credit_denomination: Option<i32>,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+pub struct UpdateWorkspaceSettingsOutput {
+    pub response_context: ResponseContext,
+    pub workspace_settings: WorkspaceSettings,
+}
+
+#[derive(cynic::InlineFragments, Debug)]
+pub enum UpdateWorkspaceSettingsResult {
+    UpdateWorkspaceSettingsOutput(Box<UpdateWorkspaceSettingsOutput>),
+    UserFacingError(UserFacingError),
+    #[cynic(fallback)]
+    Unknown,
+}