"Defines the type of a workflow structure" scalar WorkflowStructure enum FairuUploadType { STANDARD DOWNLOAD } enum FairuSortingDirection { ASC DESC } enum FairuLicenseType { STANDARD PERIOD } enum FairuWorkflowStatus { NONE TRIGGERED PROCESSING FAILED SUCCESS } enum FairuUserStatus { CREATED PENDING ACCEPTED DECLINED } enum FairuPdfSignatureRequestStatus { CREATED STARTED FAILED CANCELED DONE } enum FairuDiskType { FTP SFTP S3 } enum FairuWebhookType { NONE BASIC BEARER } enum FairuCustomDomainStatus { NONE CHECKING FAILED SUCCESS } enum FairuGallerySortingField { NAME CREATED_AT } enum FairuWorkflowType { COPYRIGHT_SPLITTING COPYRIGHT_SPLITTING_SEARCH COPYRIGHT_REPLACING COPYRIGHT_REPLACING_SEARCH } enum FairuAssetVideoVersions { LOW MEDIUM HIGH } enum FairuDmcaStatus { OPEN ACCEPTED DENIES FAILED } "A date string with format `Y-m-d`, e.g. `2011-05-23`." scalar Date "A datetime string with format `Y-m-d H:i:s`, e.g. `2018-05-23 13:43:32`." scalar DateTime type DefaultPaginator { total: Int count: Int perPage: Int currentPage: Int lastPage: Int hasMorePages: Boolean firstItem: Int lastItem: Int } type FairuAsset @key(fields: "id") { id: ID! name: String mime: String alt: String caption(raw: Boolean): String description(raw: Boolean): String copyrights: [FairuCopyright!] copyright_text: String licenses: [FairuLicense!] blocked: Boolean url(width: Int, height: Int, focal_point: String, withStoredFocalPoint: Boolean, quality: Int, version: FairuAssetVideoVersions, sign: Int): String width: Int height: Int original_width: Int original_height: Int blurhash: String focal_point: String created_at: String updated_at: String has_error: Boolean versions: [FairuAssetVideoVersions!] size: Int } type FairuFolder @key(fields: "id") { id: ID! name: String created_at: DateTime updated_at: DateTime auto_assign_copyright: Boolean copyrights: [FairuCopyright] content(page: Int, perPage: Int, folder: ID, search: String, globalSearch: Boolean, orderBy: String, orderDirection: FairuSortingDirection, onlyFolder: Boolean): FairuFolderList "Get all files recursively from this folder and all subfolders" allAssets( "Maximum number of files to return (default: 1000, max: 10000)" limit: Int ): [FairuAsset!] } union FairuEntry = FairuAsset | FairuFolder type FairuFilePdfSignatureRequest @key(fields: "id") { id: ID! status: FairuPdfSignatureRequestStatus emails: [String] file: FairuAsset config_url: String signature_id: ID } type FairuCopyright @key(fields: "id") { id: ID! name: String email: String phone: String website: String active: Boolean blocked: Boolean created_at: DateTime updated_at: DateTime } type FairuLicense @key(fields: "id") { id: ID! name: String created_at: DateTime updated_at: DateTime copyright: FairuCopyright interval: Int default: Boolean active: Boolean start: DateTime end: DateTime replace_license: Boolean replace_license_entry: FairuLicense replaced_by_license_entry: FairuLicense replace_date: DateTime type: FairuLicenseType days: Int } type FairuWorkflow @key(fields: "id") { id: ID! name: String type: FairuWorkflowType! active: Boolean status: FairuWorkflowStatus! has_error: Boolean last_at: DateTime created_at: DateTime updated_at: DateTime } type FairuUser @key(fields: "id") { id: ID! name: String email: String status: FairuUserStatus owner: Boolean } type FairuRole @key(fields: "id") { id: ID! name: String permissions: [String!] created_at: DateTime updated_at: DateTime } type FairuDiskStatus @key(fields: "id") { id: ID! syncing: Boolean open: Int pending: Int synced: Int failed: Int } type FairuDisk @key(fields: "id") { id: ID! name: String type: FairuDiskType path: String pattern: String delete_at_origin: Boolean healthy: Boolean syncing: Boolean active: Boolean credentials: FairuDiskCredentials created_at: DateTime updated_at: DateTime folder: FairuFolder } type FairuDiskFTPCredentials { ftp_host: String ftp_port: Int ftp_username: String ftp_password: String } type FairuDiskS3Credentials { key: String secret: String region: String bucket: String endpoint: String url: String } union FairuDiskCredentials = FairuDiskFTPCredentials | FairuDiskS3Credentials type FairuGallery @key(fields: "id") { id: ID! name: String description(raw: Boolean): String date: String location: String "Gallery items (loaded on-demand, default 50, max 100). Use itemsPaginated for more." items(first: Int = 50): [FairuAsset!] cover_image: FairuAsset sorting_direction: String sorting_field: String itemsPaginated(page: Int, perPage: Int, orderBy: String, orderDirection: String): FairuGalleryItemList copyright_text: String copyrights: [FairuCopyright!] active: Boolean exclude_from_list: Boolean } type FairuTenant @key(fields: "id") { id: ID! name: String avatar: FairuAsset use_ai: Boolean use_ai_onupload: Boolean ai_language: String "File policy entry - should alternative text for files be enforced" force_file_alt: Boolean "File policy entry - should a description be enforced" force_file_description: Boolean "File policy entry - should a caption text be enforced" force_file_caption: Boolean "File policy entry - should at least one copyright entry be enforced" force_filce_copyright: Boolean "File policy active?" force_file_policy: Boolean "Block files with error - if true, files with errors will not have a URL (default: true)" block_files_with_error: Boolean "Will license use enforced - if this flag is set to true - files without a valid license will be blocked" force_license: Boolean "Custom domain" custom_domain: String "If this flag is true we have identified a valid CNAME entry" custom_domain_verified: Boolean "Status of the custom domain creatoin process" custom_domain_status: FairuCustomDomainStatus webhook_url: String webhook_type: FairuWebhookType webhook_authorization: String created_at: DateTime updated_at: DateTime trial_ends_at: DateTime } type FairuDmca @key(fields: "id") { id: ID! name: String email: String reply: String reply_send: Boolean status: FairuDmcaStatus file: FairuAsset } type FairuHealthStatus { version: String healthy: Boolean } type FairuAssetList { data: [FairuAsset!] paginatorInfo: DefaultPaginator } type FairuDmcaList { data: [FairuDmca!] paginatorInfo: DefaultPaginator } type FairuDiskList { data: [FairuDisk!] paginatorInfo: DefaultPaginator } type FairuFolderList { data: [FairuEntry!] paginatorInfo: DefaultPaginator } type FairuGalleryList { data: [FairuGallery!] paginatorInfo: DefaultPaginator } type FairuGalleryItemList { data: [FairuAsset!] paginatorInfo: DefaultPaginator } type FairuCopyrightList { data: [FairuCopyright!] paginatorInfo: DefaultPaginator } type FairuLicenseList { data: [FairuLicense!] paginatorInfo: DefaultPaginator } type FairuWorkflowList { data: [FairuWorkflow!] paginatorInfo: DefaultPaginator } type FairuUserList { data: [FairuUser!] paginatorInfo: DefaultPaginator } type FairuRoleList { data: [FairuRole!] paginatorInfo: DefaultPaginator } type FairuUploadLink { "This will be the ID for the File after uploading" id: ID! "Use this url to upload the file" upload_url: String! "Call this url via GET-Request after uploading. This step is required." sync_url: String "Mime type is returned to help you identify the file type" mime: String } input FairuFolderFilter { onlyAudio: Boolean onlyImage: Boolean onlyVideo: Boolean mimeFilter: String } input FairuFileDTO { id: ID "Enter a name without the file extension - otherwise it will be part of the name" name: String "Define an alternative text" alt: String "Add an internal description to the file - html supported" description: String "This text should be used for text below the asset - html supported" caption: String active: Boolean blocked: Boolean "Define an focal point in terms of y-x-zoom eg. 0-10-1" focal_point: String "Use the copyright ids to pass the list to the file" copyrightIds: [ID] "Use the ids from license to define a license fo this file" licenseIds: [ID] } input FairuFolderDTO { id: ID name: String parent: ID autoAssignCopyright: Boolean inhertiCopyrightAssignment: Boolean copyrightIds: [ID] } input FairuCopyrightDTO { id: ID name: String email: String phone: String website: String active: Boolean blocked: Boolean } input FairuLicenseDTO { id: ID name: String copyright_id: ID interval: Int default: Boolean active: Boolean start: DateTime end: DateTime replace_license: Boolean replace_license_id: ID replace_date: DateTime type: FairuLicenseType days: Int } input FairuGalleryDTO { id: ID name: String description: String folder_id: ID active: Boolean date: DateTime exclude_from_list: Boolean location: String sorting_field: FairuGallerySortingField sorting_direction: FairuSortingDirection } input FairuDiskDTO { id: ID name: String folder_id: ID type: FairuDiskType path: String pattern: String active: Boolean delete_at_origin: Boolean credentials: FairuDiskCredentialsDTO } input FairuDiskCredentialsDTO { "For FTP/SFTP" ftp_host: String "For FTP/SFTP" ftp_port: Int "For FTP/SFTP" ftp_username: String "For FTP/SFTP" ftp_password: String "For S3" key: String "For S3" secret: String "For S3" region: String "For S3" bucket: String "For S3" endpoint: String "For S3" url: String } input FairuWorkflowDTO { id: ID type: FairuWorkflowType name: String active: Boolean structure: WorkflowStructure } input FairuRoleDTO { id: ID name: String permissions: [String!] } input FairuFilePdfSignatureRequestDTO { id: ID emails: [String] file_id: ID } input FairuDmcaComplainDTO { url: String! name: String! email: String! text: String } input FairuDmcaDTO { id: ID! name: String email: String reply: String reply_send: Boolean } """ Result of creating a new tenant via the createFairuTenant mutation. This type contains all the information needed to start using the new tenant, including a full-access API key that is only shown once. """ type FairuTenantCreationResult { "Unique identifier for the new tenant (UUID)" id: ID! "Name of the tenant" name: String! """ Full-access API key for the new tenant. IMPORTANT: This key is only shown once! Store it securely. The key has all permissions and can be used immediately to: - Upload and manage files - Create folders - Manage copyrights and licenses - Configure tenant settings - And more... If lost, generate a new key via the tenant settings or API. """ api_key: String! "ISO 8601 timestamp when the tenant was created" created_at: String! } type FairuFileAccessSignature { file_id: ID! signature: String! expires_at: String! } "Input type for multipart upload part completion" input FairuMultipartPartInput { "Part number (1-indexed)" partNumber: Int! "ETag returned by S3 after uploading the part" etag: String! } "Response from initializing a multipart upload" type FairuMultipartUploadInit { "File ID" id: ID! "S3 Upload ID - required for completing the upload" uploadId: String! "Size of each part in bytes (only if fileSize was provided)" partSize: Int "Total number of parts (only if fileSize was provided)" totalParts: Int "Presigned URLs for uploading each part (only if fileSize was provided)" parts: [FairuMultipartPart!] "URL to call after upload completion to sync metadata" sync_url: String! } "Presigned URL for uploading a single part" type FairuMultipartPart { "Part number (1-indexed)" partNumber: Int! "Presigned URL for PUT request" uploadUrl: String! } enum FairuUploadShareLinkExpiration { ONE_HOUR SIX_HOURS ONE_DAY SEVEN_DAYS THIRTY_DAYS NEVER } type FairuFolderUploadShareLink { "The ID of the upload share link" id: ID! "The shareable URL that can be used to upload files" url: String! "When the link expires (null if never)" expires_at: String "Optional name for the link" name: String "The folder ID this link uploads to" folder_id: ID! } type FairuRakuCredential { id: ID! name: String access_key_id: String! bucket: String permissions: [String!]! active: Boolean! last_used_at: DateTime expires_at: DateTime created_at: DateTime! } type FairuRakuCredentialWithSecret { id: ID! name: String access_key_id: String! secret_access_key: String! bucket: String permissions: [String!]! } "Result type for fairuAllFilesFlat query - S3-compatible flat file listing" type FairuAllFilesFlatResult { "List of entries (files and empty folders)" entries: [FairuFlatEntry!]! "Cursor for next page (null if no more pages)" nextCursor: String "True if there are more pages" hasMore: Boolean! } "Single entry in flat file listing (file or empty folder)" type FairuFlatEntry { id: ID! "File or folder name" name: String! "Full path including name (e.g., 'marketing/2024/hero.jpg' or 'archive/')" path: String! "Size in bytes (0 for folders)" size: Int! "MIME type (null for folders)" mime: String "True if this is an empty folder (S3: 0-byte key with trailing /)" isFolder: Boolean! "Last update timestamp" updatedAt: DateTime } "Directions for ordering a list of records." enum SortOrder { "Sort records in ascending order." ASC "Sort records in descending order." DESC } "Aggregate functions when ordering by a relation without specifying a column." enum OrderByRelationAggregateFunction { "Amount of items." COUNT } "Aggregate functions when ordering by a relation that may specify a column." enum OrderByRelationWithColumnAggregateFunction { "Average." AVG "Minimum." MIN "Maximum." MAX "Sum." SUM "Amount of items." COUNT } "Allows ordering a list of records." input OrderByClause { "The column that is used for ordering." column: String! "The direction that is used for ordering." order: SortOrder! } "Specify if you want to include or exclude trashed results from a query." enum Trashed { "Only return trashed results." ONLY "Return both trashed and non-trashed results." WITH "Only return non-trashed results." WITHOUT } type Query { "Simple health check query" fairuHealthCheck: FairuHealthStatus "Get all supported domains (default proxy + verified custom domains). Cached for 5-15 minutes." fairuSupportedDomains: [String!]! "Get the information of the current tenant" fairuTenant: FairuTenant "Get a single file data" fairuFile(id: ID!): FairuAsset "Get a single file by its path (e.g., '/marketing/2024/hero.jpg')" fairuFileByPath(path: String!): FairuAsset "Search globally in the tenant" fairuSearch(page: Int, perPage: Int, search: String!, orderBy: String, orderDirection: FairuSortingDirection): FairuAssetList "Get a list of files" fairuMultipleFiles(ids: [ID!]): [FairuAsset] "Calculate total size in bytes for a list of file IDs (max 2000)" fairuFilesTotalSize(ids: [ID!]!): Int! "Get only the files for a folder" fairuFiles(page: Int, perPage: Int, folder: ID): FairuAssetList "Get the folder data (files and folder) for a folder" fairuFolder(page: Int, perPage: Int, folder: ID, search: String, globalSearch: Boolean, orderBy: String, orderDirection: FairuSortingDirection, onlyFolder: Boolean): FairuFolderList "Get a single folder by its path (e.g., '/marketing/2024/summer')" fairuFolderByPath(path: String!): FairuFolder "Get all files AND empty folders with full path, cursor-paginated for S3-compatible listing (max 5000 entries per page)" fairuAllFilesFlat( "Cursor: entry ID to start after (format: 'file:uuid' or 'folder:uuid')" afterCursor: String "Maximum entries per page (default: 1000, max: 5000)" limit: Int ): FairuAllFilesFlatResult! "Get single gallery" fairuGallery(id: ID!): FairuGallery "Get list of galleries that should be displayed" fairuGalleries(tenants: [ID!]!, page: Int, perPage: Int, from: String, until: String, search: String, orderBy: String, orderDirection: String): FairuGalleryList "Get a list of copyrights for the tenant" fairuCopyrights(page: Int, perPage: Int): FairuCopyrightList "Get a single copyright entry in the tenant" fairuCopyright(id: ID): FairuCopyright "Get a list of licenses defined in the tenant" fairuLicenses(page: Int, perPage: Int): FairuLicenseList "Get a single license information" fairuLicense(id: ID): FairuLicense "Get a list of defined workflows of the tenant" fairuWorkflows(page: Int, perPage: Int): FairuWorkflowList "Get a single workflow information" fairuWorkflow(id: ID!): FairuWorkflow "Get a list of users attached to the tenant" fairuUsers(page: Int, perPage: Int): FairuUserList "Get the information of a fairu user withing the tenant" fairuUser(id: ID!): FairuUser "Get a list of roles defined in the tenant" fairuRoles(page: Int, perPage: Int): FairuRoleList "Get a single role information" fairuRole(id: ID!): FairuRole "Get a list of sync configuration for the tenant" fairuDisks(page: Int, perPage: Int): FairuDiskList "Get a single sync disk configuration" fairuDisk(id: ID!): FairuDisk "Get a single sync disk status" fairuDiskStatus(id: ID!): FairuDiskStatus "Get a list of sync configuration for the tenant" fairuDmcas(page: Int, perPage: Int): FairuDmcaList "Get a single dmca report" fairuDmca(id: ID!): FairuDmca "Get a list of Raku credentials (S3-compatible storage) for the tenant" fairuRakuCredentials: [FairuRakuCredential!]! } type Mutation { """ Create a new tenant (workspace) via API. This mutation is designed for programmatic tenant provisioning, typically used by: - Partner integrations that need to create workspaces for their customers - Automated onboarding systems - White-label deployments ## Authentication Requires a special "provisioning token" with the `tenant::create` ability. This is a global permission (not tied to any existing tenant). To obtain a provisioning token, contact your administrator or use the admin panel to generate one for your user account. ## What happens on creation 1. A new tenant (workspace) is created with the given name 2. The authenticated user becomes the owner with full admin rights 3. A full-access API key is generated for the new tenant 4. The API key is returned in the response (store it securely!) ## Response The mutation returns: - `id`: The unique tenant ID (UUID) - `name`: The tenant name - `api_key`: A full-access API key for the new tenant (shown only once!) - `created_at`: ISO 8601 timestamp ## Example ```graphql mutation { createFairuTenant(name: "My New Workspace") { id name api_key created_at } } ``` ## Important The `api_key` is only shown once in this response. Store it securely! If lost, you'll need to generate a new one via the tenant settings. """ createFairuTenant( "The name for the new tenant/workspace (2-255 characters)" name: String! ): FairuTenantCreationResult! """ Update the current tenant's settings. Requires the `tenant::update` permission on the current tenant. All fields are optional - only provided fields will be updated. ## Example ```graphql mutation { updateFairuTenant( name: "My Renamed Workspace" use_ai: true force_file_alt: true ) { id name use_ai } } ``` """ updateFairuTenant( "Tenant name" name: String "Enforce license assignment for files" force_license: Boolean "Enable AI features" use_ai: Boolean "Run AI analysis automatically on upload" use_ai_onupload: Boolean "Avatar file ID" avatar_id: ID "AI processing language (e.g., 'en', 'de')" ai_language: String "Enable NSFW detection" ai_nsfw: Boolean "Blur detected faces in images" ai_blur_faces: Boolean "Require alt text for files" force_file_alt: Boolean "Require description for files" force_file_description: Boolean "Require caption for files" force_file_caption: Boolean "Require copyright for files" force_file_copyright: Boolean "Enable file policy enforcement" force_file_policy: Boolean "Block files with error - if false, files with errors will still have a URL" block_files_with_error: Boolean "Custom domain (e.g., 'assets.example.com')" custom_domain: String "Hide dotfiles (files starting with .)" hide_dotfiles: Boolean ): FairuTenant createFairuUploadLink( "Type of upload you want to create" type: FairuUploadType "Download url just needed to be added if type is download" download_url: String "Folder ID" folder: ID "Filename should be passed to provide a name" filename: String! "If you want to pass an UUID for your file you can create an UUID and pass it here. This field is not mandatory" id: ID "File size in bytes - stored directly to avoid sync delay" fileSize: Int "Alt text for your asset" alt: String "Caption text for your asset" caption: String "Description - this will be is for internal purpose" description: String "Focal point based on top-left-zoom logic" focal_point: String "Copyright text - which will be evaluated via our AI service." copyright: String ): FairuUploadLink "Initialize a multipart upload for large files (>5MB)" initFairuMultipartUpload( "Filename should be passed to provide a name" filename: String! "Folder ID" folder: ID "Total file size in bytes - optional, if provided all part URLs are returned upfront" fileSize: Int "Content type of the file" contentType: String "Alt text for your asset" alt: String "Caption text for your asset" caption: String "Description - this will be for internal purpose" description: String "Copyright text - which will be evaluated via our AI service" copyright: String ): FairuMultipartUploadInit! "Get a presigned URL for uploading a specific part (for S3 Gateway use)" getFairuMultipartPartUrl( "The file ID returned from initFairuMultipartUpload" fileId: ID! "The upload ID returned from initFairuMultipartUpload" uploadId: String! "Part number (1-indexed)" partNumber: Int! ): FairuMultipartPart! "Complete a multipart upload after all parts have been uploaded" completeFairuMultipartUpload( "The file ID returned from initFairuMultipartUpload" fileId: ID! "The upload ID returned from initFairuMultipartUpload" uploadId: String! "Array of uploaded parts with their ETags" parts: [FairuMultipartPartInput!]! ): FairuUploadLink! "Abort a multipart upload and clean up" abortFairuMultipartUpload( "The file ID returned from initFairuMultipartUpload" fileId: ID! "The upload ID returned from initFairuMultipartUpload" uploadId: String! ): Boolean! "Create a gallery" createFairuGallery(data: FairuGalleryDTO!): FairuGallery "Update a gallery and it's meta data" updateFairuGallery(data: FairuGalleryDTO!): FairuGallery "Delete a gallery" deleteFairuGallery(id: ID!): Boolean "Create shareable gallery link" createFairuGalleryShareLink(id: ID!): String "Create a sync disk entry" createFairuDisk(data: FairuDiskDTO!): FairuDisk "Update a sync disk and it's meta data" updateFairuDisk(data: FairuDiskDTO!): FairuDisk "Delete a disk" deleteFairuDisk(id: ID!): Boolean "Create a role" createFairuRole(data: FairuRoleDTO!): FairuRole "Update a role" updateFairuRole(data: FairuRoleDTO!): FairuRole "Delete a role" deleteFairuRole(id: ID!): Boolean "Invite an user to the tenant" inviteFairuUser(email: String!, role: ID!): Boolean "Delete an user from the tenant - user will not be deleted by itself" deleteFairuUser(id: ID!): Boolean "Create a workflow" createFairuWorkflow(data: FairuWorkflowDTO!): FairuWorkflow "Update a workflow and it's meta data" updateFairuWorkflow(data: FairuWorkflowDTO!): FairuWorkflow "Delete a workflow" deleteFairuWorkflow(id: ID!): Boolean "Update meta data for a file" updateFairuFile(data: FairuFileDTO!): FairuAsset "Delete a single file" deleteFairuFile(id: ID!): Boolean "Block a file" blockFairuFile(id: ID!): Boolean "Remove block a file" unblockFairuFile(id: ID!): Boolean "Rename a file" renameFairuFile(id: ID!, name: String!): FairuAsset "Move a file" moveFairuFile(id: ID!, parent: ID): Boolean "Move a folder" moveFairuFolder(id: ID!, parent: ID): Boolean "Duplicate a file" duplicateFairuFile(id: ID!, parent: ID): Boolean "Trigger file download process" redownloadFairuFile(id: ID!): Boolean "Create an upload link to replace an existing file's content in S3" replaceFairuFile(id: ID!): FairuUploadLink "Create a folder" createFairuFolder(data: FairuFolderDTO!): FairuFolder "Update a folder and it's meta data" updateFairuFolder(data: FairuFolderDTO!): FairuFolder "Delete a single folder" deleteFairuFolder(id: ID!): Boolean "Rename a folder" renameFairuFolder(id: ID!, name: String!): FairuFolder "Create a ftp connectoin to the folder" createFairuFolderFTP(id: ID!): FairuDisk "Create a copyright" createFairuCopyright(data: FairuCopyrightDTO!): FairuCopyright "Update a copyright" updateFairuCopyright(data: FairuCopyrightDTO!): FairuCopyright "Delete a copyright entry" deleteFairuCopyright(id: ID!, deleteAssets: Boolean, deleteLicenses: Boolean): Boolean "Create a license" createFairuLicense(data: FairuLicenseDTO!): FairuLicense "Update a license" updateFairuLicense(data: FairuLicenseDTO!): FairuLicense "Delete a license entry" deleteFairuLicense(id: ID!, deleteAssets: Boolean): Boolean "Create a pdf signatur request" createFairuPdfSignatureRequest(data: FairuFilePdfSignatureRequestDTO!): FairuFilePdfSignatureRequest "Start a pdf signatur request" startFairuPdfSignatureRequest(id: ID!): FairuFilePdfSignatureRequest "Cancel a pdf signatur request" cancelFairuPdfSignatureRequest(id: ID!): Boolean "Create a dcma complain" createFairuDmcaComplain(data: FairuDmcaComplainDTO!): Boolean "Create a dcma complain" updateFairuDmcaComplain(data: FairuDmcaDTO!): FairuDmca "Generate HMAC access signatures for private files" createFairuFileAccessSignature(ids: [ID!]!, valid_for_minutes: Int): [FairuFileAccessSignature!]! "Create Raku credentials (S3-compatible storage) for the tenant" createFairuRakuCredential(name: String, bucket: String, permissions: [String!]!): FairuRakuCredentialWithSecret! "Revoke Raku credentials (deactivate but keep for audit)" revokeFairuRakuCredential(id: ID!): Boolean! "Delete Raku credentials permanently" deleteFairuRakuCredential(id: ID!): Boolean! "Create an upload share link for a folder - anyone with this link can upload files to the folder" createFairuFolderUploadShareLink( "The folder ID to create the upload link for" id: ID! "How long the link should be valid (default: 7 days)" expires_in: FairuUploadShareLinkExpiration "Optional name to identify the link" name: String ): FairuFolderUploadShareLink """ Get the proxy URL for a file by its path (no authentication required). Returns null if: - The tenant or file doesn't exist - The file is private - The file has errors (if block_files_with_error is enabled) ## Example ```graphql mutation { fairuFileUrlByPath( tenant: "550e8400-e29b-41d4-a716-446655440000" path: "/marketing/hero.jpg" width: 800 quality: 80 ) } ``` """ fairuFileUrlByPath( "The tenant ID (UUID)" tenant: ID! "The file path (e.g., '/marketing/2024/hero.jpg')" path: String! "Resize width" width: Int "Resize height" height: Int "Focal point for cropping" focal_point: String "Use the stored focal point from the file" withStoredFocalPoint: Boolean "Image quality (1-100)" quality: Int "Video version (LOW, MEDIUM, HIGH)" version: FairuAssetVideoVersions ): String }