@leav/ui 0.4.0 → 1.0.0-4c37a197

package/dist/_gqlTypes/index.d.ts

@@ -136,11 +136,14 @@ export type AttributeInput = {
     linked_library?: InputMaybe<Scalars['String']>;
     linked_tree?: InputMaybe<Scalars['String']>;
     metadata_fields?: InputMaybe<Array<Scalars['String']>>;
+    multi_link_display_option?: InputMaybe<MultiDisplayOption>;
+    multi_tree_display_option?: InputMaybe<MultiDisplayOption>;
     multiple_values?: InputMaybe<Scalars['Boolean']>;
     permissions_conf?: InputMaybe<TreepermissionsConfInput>;
     readonly?: InputMaybe<Scalars['Boolean']>;
     required?: InputMaybe<Scalars['Boolean']>;
     reverse_link?: InputMaybe<Scalars['String']>;
+    settings?: InputMaybe<Scalars['JSONObject']>;
     type?: InputMaybe<AttributeType>;
     unique?: InputMaybe<Scalars['Boolean']>;
     values_list?: InputMaybe<ValuesListConfInput>;
@@ -181,6 +184,11 @@ export declare enum AvailableLanguage {
     en = "en",
     fr = "fr"
 }
+export type ChildrenAsRecordValuePermissionFilterInput = {
+    action: RecordPermissionsActions;
+    attributeId: Scalars['ID'];
+    libraryId: Scalars['ID'];
+};
 export type CreateRecordDataInput = {
     values?: InputMaybe<Array<ValueBatchInput>>;
     version?: InputMaybe<Array<ValueVersionInput>>;
@@ -246,6 +254,11 @@ export type FormInput = {
     id: Scalars['ID'];
     label?: InputMaybe<Scalars['SystemTranslation']>;
     library: Scalars['ID'];
+    sidePanel?: InputMaybe<FormSidePanelInput>;
+};
+export type FormSidePanelInput = {
+    enable: Scalars['Boolean'];
+    isOpenByDefault: Scalars['Boolean'];
 };
 export declare enum FormsSortableFields {
     id = "id",
@@ -261,6 +274,7 @@ export type GlobalSettingsInput = {
     favicon?: InputMaybe<GlobalSettingsFileInput>;
     icon?: InputMaybe<GlobalSettingsFileInput>;
     name?: InputMaybe<Scalars['String']>;
+    settings?: InputMaybe<Scalars['JSONObject']>;
 };
 export declare enum IoTypes {
     boolean = "boolean",
@@ -292,6 +306,7 @@ export declare enum LibrariesSortableFields {
 export declare enum LibraryBehavior {
     directories = "directories",
     files = "files",
+    join = "join",
     standard = "standard"
 }
 export type LibraryIconInput = {
@@ -306,9 +321,11 @@ export type LibraryInput = {
     icon?: InputMaybe<LibraryIconInput>;
     id: Scalars['ID'];
     label?: InputMaybe<Scalars['SystemTranslation']>;
+    mandatoryAttribute?: InputMaybe<Scalars['ID']>;
     permissions_conf?: InputMaybe<TreepermissionsConfInput>;
     previewsSettings?: InputMaybe<Array<LibraryPreviewsSettingsInput>>;
     recordIdentityConf?: InputMaybe<RecordIdentityConfInput>;
+    settings?: InputMaybe<Scalars['JSONObject']>;
 };
 export type LibraryPreviewsSettingsInput = {
     description?: InputMaybe<Scalars['SystemTranslationOptional']>;
@@ -389,6 +406,11 @@ export type LogTopicRecordFilterInput = {
     id?: InputMaybe<Scalars['String']>;
     libraryId?: InputMaybe<Scalars['String']>;
 };
+export declare enum MultiDisplayOption {
+    avatar = "avatar",
+    badge_qty = "badge_qty",
+    tag = "tag"
+}
 export type Pagination = {
     limit: Scalars['Int'];
     offset: Scalars['Int'];
@@ -431,6 +453,7 @@ export declare enum PermissionsActions {
     admin_access_applications = "admin_access_applications",
     admin_access_attributes = "admin_access_attributes",
     admin_access_libraries = "admin_access_libraries",
+    admin_access_logs = "admin_access_logs",
     admin_access_permissions = "admin_access_permissions",
     admin_access_tasks = "admin_access_tasks",
     admin_access_trees = "admin_access_trees",
@@ -458,6 +481,7 @@ export declare enum PermissionsActions {
     admin_edit_permission = "admin_edit_permission",
     admin_edit_tree = "admin_edit_tree",
     admin_edit_version_profile = "admin_edit_version_profile",
+    admin_import_config_clear_database = "admin_import_config_clear_database",
     admin_library = "admin_library",
     admin_manage_global_preferences = "admin_manage_global_preferences",
     create_record = "create_record",
@@ -537,6 +561,12 @@ export type RecordInput = {
     id: Scalars['ID'];
     library: Scalars['String'];
 };
+export declare enum RecordPermissionsActions {
+    access_record = "access_record",
+    create_record = "create_record",
+    delete_record = "delete_record",
+    edit_record = "edit_record"
+}
 export type RecordSortInput = {
     field: Scalars['String'];
     order: SortOrder;
@@ -640,6 +670,7 @@ export type TreeInput = {
     label?: InputMaybe<Scalars['SystemTranslation']>;
     libraries?: InputMaybe<Array<TreeLibraryInput>>;
     permissions_conf?: InputMaybe<Array<TreeNodePermissionsConfInput>>;
+    settings?: InputMaybe<Scalars['JSONObject']>;
 };
 export type TreeLibraryInput = {
     library: Scalars['ID'];
@@ -681,11 +712,13 @@ export type ValueBatchInput = {
     attribute?: InputMaybe<Scalars['ID']>;
     id_value?: InputMaybe<Scalars['ID']>;
     metadata?: InputMaybe<Array<InputMaybe<ValueMetadataInput>>>;
+    /**  Use "\__empty_value__" to set an empty value  */
     payload?: InputMaybe<Scalars['String']>;
 };
 export type ValueInput = {
     id_value?: InputMaybe<Scalars['ID']>;
     metadata?: InputMaybe<Array<InputMaybe<ValueMetadataInput>>>;
+    /**  Use "\__empty_value__" to set an empty value  */
     payload?: InputMaybe<Scalars['String']>;
     version?: InputMaybe<Array<InputMaybe<ValueVersionInput>>>;
 };
@@ -823,6 +856,8 @@ export type AttributeDetailsLinkAttributeFragment = {
     label?: any | null;
     description?: any | null;
     multiple_values: boolean;
+    multi_link_display_option?: MultiDisplayOption | null;
+    multi_tree_display_option?: MultiDisplayOption | null;
     linked_library?: {
         id: string;
         label?: any | null;
@@ -860,6 +895,8 @@ export type AttributeDetailsStandardAttributeFragment = {
     label?: any | null;
     description?: any | null;
     multiple_values: boolean;
+    multi_link_display_option?: MultiDisplayOption | null;
+    multi_tree_display_option?: MultiDisplayOption | null;
     metadata_fields?: Array<{
         id: string;
         label?: any | null;
@@ -892,6 +929,8 @@ export type AttributeDetailsTreeAttributeFragment = {
     label?: any | null;
     description?: any | null;
     multiple_values: boolean;
+    multi_link_display_option?: MultiDisplayOption | null;
+    multi_tree_display_option?: MultiDisplayOption | null;
     linked_tree?: {
         id: string;
         label?: any | null;
@@ -1750,6 +1789,261 @@ export type RecordFormElementFragment = {
         key: string;
         value: any;
     }>;
+    joinLibraryContext?: {
+        mandatoryAttribute: {
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            required: boolean;
+            multiple_values: boolean;
+            compute: boolean;
+            linked_library?: {
+                id: string;
+                label?: any | null;
+                behavior: LibraryBehavior;
+                permissions?: {
+                    create_record: boolean;
+                } | null;
+            } | null;
+            linkValuesList?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<{
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        subLabel?: string | null;
+                        color?: string | null;
+                        preview?: IPreviewScalar | null;
+                        library: {
+                            id: string;
+                            label?: any | null;
+                        };
+                    };
+                }> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            versions_conf?: {
+                versionable: boolean;
+                profile?: {
+                    id: string;
+                    trees: Array<{
+                        id: string;
+                        label?: any | null;
+                    }>;
+                } | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+                label?: any | null;
+                description?: any | null;
+                type: AttributeType;
+                format?: AttributeFormat | null;
+                system: boolean;
+                readonly: boolean;
+                multiple_values: boolean;
+                permissions: {
+                    access_attribute: boolean;
+                    edit_value: boolean;
+                };
+                values_list?: {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    dateRangeValues?: Array<{
+                        from?: string | null;
+                        to?: string | null;
+                    }> | null;
+                } | {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    values?: Array<string> | null;
+                } | null;
+                metadata_fields?: Array<{
+                    id: string;
+                }> | null;
+            }> | null;
+        } | {
+            character_limit?: number | null;
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            required: boolean;
+            multiple_values: boolean;
+            compute: boolean;
+            values_list?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                dateRangeValues?: Array<{
+                    from?: string | null;
+                    to?: string | null;
+                }> | null;
+            } | {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            versions_conf?: {
+                versionable: boolean;
+                profile?: {
+                    id: string;
+                    trees: Array<{
+                        id: string;
+                        label?: any | null;
+                    }>;
+                } | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+                label?: any | null;
+                description?: any | null;
+                type: AttributeType;
+                format?: AttributeFormat | null;
+                system: boolean;
+                readonly: boolean;
+                multiple_values: boolean;
+                permissions: {
+                    access_attribute: boolean;
+                    edit_value: boolean;
+                };
+                values_list?: {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    dateRangeValues?: Array<{
+                        from?: string | null;
+                        to?: string | null;
+                    }> | null;
+                } | {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    values?: Array<string> | null;
+                } | null;
+                metadata_fields?: Array<{
+                    id: string;
+                }> | null;
+            }> | null;
+        } | {
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            required: boolean;
+            multiple_values: boolean;
+            compute: boolean;
+            linked_tree?: {
+                id: string;
+                label?: any | null;
+            } | null;
+            treeValuesList?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<{
+                    id: string;
+                    record: {
+                        id: string;
+                        whoAmI: {
+                            id: string;
+                            label?: string | null;
+                            subLabel?: string | null;
+                            color?: string | null;
+                            preview?: IPreviewScalar | null;
+                            library: {
+                                id: string;
+                                label?: any | null;
+                            };
+                        };
+                    };
+                    ancestors?: Array<{
+                        record: {
+                            id: string;
+                            whoAmI: {
+                                id: string;
+                                label?: string | null;
+                                subLabel?: string | null;
+                                color?: string | null;
+                                preview?: IPreviewScalar | null;
+                                library: {
+                                    id: string;
+                                    label?: any | null;
+                                };
+                            };
+                        };
+                    }> | null;
+                }> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            versions_conf?: {
+                versionable: boolean;
+                profile?: {
+                    id: string;
+                    trees: Array<{
+                        id: string;
+                        label?: any | null;
+                    }>;
+                } | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+                label?: any | null;
+                description?: any | null;
+                type: AttributeType;
+                format?: AttributeFormat | null;
+                system: boolean;
+                readonly: boolean;
+                multiple_values: boolean;
+                permissions: {
+                    access_attribute: boolean;
+                    edit_value: boolean;
+                };
+                values_list?: {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    dateRangeValues?: Array<{
+                        from?: string | null;
+                        to?: string | null;
+                    }> | null;
+                } | {
+                    enable: boolean;
+                    allowFreeEntry?: boolean | null;
+                    allowListUpdate?: boolean | null;
+                    values?: Array<string> | null;
+                } | null;
+                metadata_fields?: Array<{
+                    id: string;
+                }> | null;
+            }> | null;
+        };
+    } | null;
 };
 export type ValueDetailsLinkValueFragment = {
     id_value?: string | null;
@@ -2424,9 +2718,264 @@ export type StandardValuesListFragmentStandardStringValuesListConfFragment = {
     values?: Array<string> | null;
 };
 export type StandardValuesListFragmentFragment = StandardValuesListFragmentStandardDateRangeValuesListConfFragment | StandardValuesListFragmentStandardStringValuesListConfFragment;
-export type TreeDetailsFragment = {
-    id: string;
-    label?: any | null;
+export type JoinLibraryContextFragment = {
+    mandatoryAttribute: {
+        id: string;
+        label?: any | null;
+        description?: any | null;
+        type: AttributeType;
+        format?: AttributeFormat | null;
+        system: boolean;
+        readonly: boolean;
+        required: boolean;
+        multiple_values: boolean;
+        compute: boolean;
+        linked_library?: {
+            id: string;
+            label?: any | null;
+            behavior: LibraryBehavior;
+            permissions?: {
+                create_record: boolean;
+            } | null;
+        } | null;
+        linkValuesList?: {
+            enable: boolean;
+            allowFreeEntry?: boolean | null;
+            allowListUpdate?: boolean | null;
+            values?: Array<{
+                id: string;
+                whoAmI: {
+                    id: string;
+                    label?: string | null;
+                    subLabel?: string | null;
+                    color?: string | null;
+                    preview?: IPreviewScalar | null;
+                    library: {
+                        id: string;
+                        label?: any | null;
+                    };
+                };
+            }> | null;
+        } | null;
+        permissions: {
+            access_attribute: boolean;
+            edit_value: boolean;
+        };
+        versions_conf?: {
+            versionable: boolean;
+            profile?: {
+                id: string;
+                trees: Array<{
+                    id: string;
+                    label?: any | null;
+                }>;
+            } | null;
+        } | null;
+        metadata_fields?: Array<{
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            multiple_values: boolean;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            values_list?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                dateRangeValues?: Array<{
+                    from?: string | null;
+                    to?: string | null;
+                }> | null;
+            } | {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+            }> | null;
+        }> | null;
+    } | {
+        character_limit?: number | null;
+        id: string;
+        label?: any | null;
+        description?: any | null;
+        type: AttributeType;
+        format?: AttributeFormat | null;
+        system: boolean;
+        readonly: boolean;
+        required: boolean;
+        multiple_values: boolean;
+        compute: boolean;
+        values_list?: {
+            enable: boolean;
+            allowFreeEntry?: boolean | null;
+            allowListUpdate?: boolean | null;
+            dateRangeValues?: Array<{
+                from?: string | null;
+                to?: string | null;
+            }> | null;
+        } | {
+            enable: boolean;
+            allowFreeEntry?: boolean | null;
+            allowListUpdate?: boolean | null;
+            values?: Array<string> | null;
+        } | null;
+        permissions: {
+            access_attribute: boolean;
+            edit_value: boolean;
+        };
+        versions_conf?: {
+            versionable: boolean;
+            profile?: {
+                id: string;
+                trees: Array<{
+                    id: string;
+                    label?: any | null;
+                }>;
+            } | null;
+        } | null;
+        metadata_fields?: Array<{
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            multiple_values: boolean;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            values_list?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                dateRangeValues?: Array<{
+                    from?: string | null;
+                    to?: string | null;
+                }> | null;
+            } | {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+            }> | null;
+        }> | null;
+    } | {
+        id: string;
+        label?: any | null;
+        description?: any | null;
+        type: AttributeType;
+        format?: AttributeFormat | null;
+        system: boolean;
+        readonly: boolean;
+        required: boolean;
+        multiple_values: boolean;
+        compute: boolean;
+        linked_tree?: {
+            id: string;
+            label?: any | null;
+        } | null;
+        treeValuesList?: {
+            enable: boolean;
+            allowFreeEntry?: boolean | null;
+            allowListUpdate?: boolean | null;
+            values?: Array<{
+                id: string;
+                record: {
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        subLabel?: string | null;
+                        color?: string | null;
+                        preview?: IPreviewScalar | null;
+                        library: {
+                            id: string;
+                            label?: any | null;
+                        };
+                    };
+                };
+                ancestors?: Array<{
+                    record: {
+                        id: string;
+                        whoAmI: {
+                            id: string;
+                            label?: string | null;
+                            subLabel?: string | null;
+                            color?: string | null;
+                            preview?: IPreviewScalar | null;
+                            library: {
+                                id: string;
+                                label?: any | null;
+                            };
+                        };
+                    };
+                }> | null;
+            }> | null;
+        } | null;
+        permissions: {
+            access_attribute: boolean;
+            edit_value: boolean;
+        };
+        versions_conf?: {
+            versionable: boolean;
+            profile?: {
+                id: string;
+                trees: Array<{
+                    id: string;
+                    label?: any | null;
+                }>;
+            } | null;
+        } | null;
+        metadata_fields?: Array<{
+            id: string;
+            label?: any | null;
+            description?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            system: boolean;
+            readonly: boolean;
+            multiple_values: boolean;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+            values_list?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                dateRangeValues?: Array<{
+                    from?: string | null;
+                    to?: string | null;
+                }> | null;
+            } | {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            metadata_fields?: Array<{
+                id: string;
+            }> | null;
+        }> | null;
+    };
+};
+export type TreeDetailsFragment = {
+    id: string;
+    label?: any | null;
     behavior: TreeBehavior;
     system: boolean;
     libraries: Array<{
@@ -2561,12 +3110,162 @@ export type ViewDetailsFilterFragment = {
         label?: any | null;
     } | null;
 };
+export type AttributesByLibAttributeWithPermissionsLinkAttributeFragment = {
+    id: string;
+    type: AttributeType;
+    format?: AttributeFormat | null;
+    label?: any | null;
+    multiple_values: boolean;
+    system: boolean;
+    readonly: boolean;
+    permissions: {
+        access_attribute: boolean;
+    };
+    valuesList?: {
+        enable: boolean;
+        allowFreeEntry?: boolean | null;
+        allowListUpdate?: boolean | null;
+        linkedValues?: Array<{
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
+                };
+            };
+        }> | null;
+    } | null;
+    linked_library?: {
+        id: string;
+    } | null;
+};
+export type AttributesByLibAttributeWithPermissionsStandardAttributeFragment = {
+    id: string;
+    type: AttributeType;
+    format?: AttributeFormat | null;
+    label?: any | null;
+    multiple_values: boolean;
+    system: boolean;
+    readonly: boolean;
+    embedded_fields?: Array<{
+        id: string;
+        format?: AttributeFormat | null;
+        label?: any | null;
+    } | null> | null;
+    valuesList?: {
+        enable: boolean;
+        allowFreeEntry?: boolean | null;
+        allowListUpdate?: boolean | null;
+        dateRangeValues?: Array<{
+            from?: string | null;
+            to?: string | null;
+        }> | null;
+    } | {
+        enable: boolean;
+        allowFreeEntry?: boolean | null;
+        allowListUpdate?: boolean | null;
+        values?: Array<string> | null;
+    } | null;
+    permissions: {
+        access_attribute: boolean;
+    };
+};
+export type AttributesByLibAttributeWithPermissionsTreeAttributeFragment = {
+    id: string;
+    type: AttributeType;
+    format?: AttributeFormat | null;
+    label?: any | null;
+    multiple_values: boolean;
+    system: boolean;
+    readonly: boolean;
+    linked_tree?: {
+        id: string;
+        label?: any | null;
+        libraries: Array<{
+            library: {
+                id: string;
+                label?: any | null;
+            };
+        }>;
+    } | null;
+    permissions: {
+        access_attribute: boolean;
+    };
+};
+export type AttributesByLibAttributeWithPermissionsFragment = AttributesByLibAttributeWithPermissionsLinkAttributeFragment | AttributesByLibAttributeWithPermissionsStandardAttributeFragment | AttributesByLibAttributeWithPermissionsTreeAttributeFragment;
+export type AttributesByLibLinkAttributeWithPermissionsFragment = {
+    valuesList?: {
+        enable: boolean;
+        allowFreeEntry?: boolean | null;
+        allowListUpdate?: boolean | null;
+        linkedValues?: Array<{
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
+                };
+            };
+        }> | null;
+    } | null;
+    linked_library?: {
+        id: string;
+    } | null;
+};
+export type StandardAttributeDetailsFragment = {
+    id: string;
+    type: AttributeType;
+    embedded_fields?: Array<{
+        id: string;
+        format?: AttributeFormat | null;
+        label?: any | null;
+    } | null> | null;
+    valuesList?: {
+        enable: boolean;
+        allowFreeEntry?: boolean | null;
+        allowListUpdate?: boolean | null;
+        values?: Array<string> | null;
+    } | null;
+};
 export type LinkAttributeDetailsFragment = {
     label?: any | null;
+    type: AttributeType;
     linked_library?: {
         id: string;
         label?: any | null;
     } | null;
+    valuesList?: {
+        allowFreeEntry?: boolean | null;
+        enable: boolean;
+        linkedValues?: Array<{
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                library: {
+                    id: string;
+                };
+            };
+        }> | null;
+    } | null;
+};
+export type TreeAttributeDetailsFragment = {
+    id: string;
+    label?: any | null;
+    linked_tree?: {
+        id: string;
+        label?: any | null;
+    } | null;
 };
 export type AttributePropertiesFragment = {
     id: string;
@@ -2574,6 +3273,8 @@ export type AttributePropertiesFragment = {
     type: AttributeType;
     format?: AttributeFormat | null;
     multiple_values: boolean;
+    multi_link_display_option?: MultiDisplayOption | null;
+    multi_tree_display_option?: MultiDisplayOption | null;
 };
 export type PropertyValueLinkValueFragment = {
     linkPayload?: {
@@ -2626,6 +3327,8 @@ export type LinkPropertyLinkValueFragment = {
                 type: AttributeType;
                 format?: AttributeFormat | null;
                 multiple_values: boolean;
+                multi_link_display_option?: MultiDisplayOption | null;
+                multi_tree_display_option?: MultiDisplayOption | null;
             };
             values: Array<{
                 linkPayload?: {
@@ -2685,6 +3388,9 @@ export type LibraryAttributeLinkAttributeFragment = {
     id: string;
     type: AttributeType;
     label?: any | null;
+    permissions: {
+        access_attribute: boolean;
+    };
     linked_library?: {
         id: string;
         label?: any | null;
@@ -2701,11 +3407,17 @@ export type LibraryAttributeStandardAttributeFragment = {
     id: string;
     type: AttributeType;
     label?: any | null;
+    permissions: {
+        access_attribute: boolean;
+    };
 };
 export type LibraryAttributeTreeAttributeFragment = {
     id: string;
     type: AttributeType;
     label?: any | null;
+    permissions: {
+        access_attribute: boolean;
+    };
 };
 export type LibraryAttributeFragment = LibraryAttributeLinkAttributeFragment | LibraryAttributeStandardAttributeFragment | LibraryAttributeTreeAttributeFragment;
 export type LibraryAttributeLinkFragment = {
@@ -2720,6 +3432,47 @@ export type LibraryAttributeLinkFragment = {
         }> | null;
     } | null;
 };
+export type RecordHistoryLogEntryFragment = {
+    action?: LogAction | null;
+    time: number;
+    topic?: {
+        attribute?: {
+            id: string;
+            label?: any | null;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            multiple_values: boolean;
+        } | null;
+    } | null;
+    user: {
+        id: string;
+        whoAmI: {
+            id: string;
+            library: {
+                id: string;
+            };
+        };
+        properties: Array<{
+            attributeId: string;
+            values: Array<{
+                payload?: any | null;
+            }>;
+        }>;
+    };
+    before?: {
+        asString?: string | null;
+    } | null;
+    after?: {
+        asString?: string | null;
+    } | null;
+};
+export type RecordHistoryLogAttributeFragment = {
+    id: string;
+    label?: any | null;
+    type: AttributeType;
+    format?: AttributeFormat | null;
+    multiple_values: boolean;
+};
 export type CheckApplicationExistenceQueryVariables = Exact<{
     id?: InputMaybe<Scalars['ID']>;
     endpoint?: InputMaybe<Scalars['String']>;
@@ -2840,6 +3593,8 @@ export type GetAttributeByIdQuery = {
             label?: any | null;
             description?: any | null;
             multiple_values: boolean;
+            multi_link_display_option?: MultiDisplayOption | null;
+            multi_tree_display_option?: MultiDisplayOption | null;
             linked_library?: {
                 id: string;
                 label?: any | null;
@@ -2876,6 +3631,8 @@ export type GetAttributeByIdQuery = {
             label?: any | null;
             description?: any | null;
             multiple_values: boolean;
+            multi_link_display_option?: MultiDisplayOption | null;
+            multi_tree_display_option?: MultiDisplayOption | null;
             metadata_fields?: Array<{
                 id: string;
                 label?: any | null;
@@ -2907,6 +3664,8 @@ export type GetAttributeByIdQuery = {
             label?: any | null;
             description?: any | null;
             multiple_values: boolean;
+            multi_link_display_option?: MultiDisplayOption | null;
+            multi_tree_display_option?: MultiDisplayOption | null;
             linked_tree?: {
                 id: string;
                 label?: any | null;
@@ -3049,6 +3808,8 @@ export type SaveAttributeMutation = {
         label?: any | null;
         description?: any | null;
         multiple_values: boolean;
+        multi_link_display_option?: MultiDisplayOption | null;
+        multi_tree_display_option?: MultiDisplayOption | null;
         linked_library?: {
             id: string;
             label?: any | null;
@@ -3085,6 +3846,8 @@ export type SaveAttributeMutation = {
         label?: any | null;
         description?: any | null;
         multiple_values: boolean;
+        multi_link_display_option?: MultiDisplayOption | null;
+        multi_tree_display_option?: MultiDisplayOption | null;
         metadata_fields?: Array<{
             id: string;
             label?: any | null;
@@ -3116,6 +3879,8 @@ export type SaveAttributeMutation = {
         label?: any | null;
         description?: any | null;
         multiple_values: boolean;
+        multi_link_display_option?: MultiDisplayOption | null;
+        multi_tree_display_option?: MultiDisplayOption | null;
         linked_tree?: {
             id: string;
             label?: any | null;
@@ -3569,6 +4334,83 @@ export type IsAllowedQuery = {
         allowed?: boolean | null;
     }> | null;
 };
+export type ActivateNewRecordMutationVariables = Exact<{
+    libraryId: Scalars['ID'];
+    recordId: Scalars['ID'];
+    formId?: InputMaybe<Scalars['String']>;
+}>;
+export type ActivateNewRecordMutation = {
+    activateNewRecord: {
+        record?: {
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
+                };
+            };
+        } | null;
+        valuesErrors?: Array<{
+            type: string;
+            attribute: string;
+            input?: string | null;
+            message: string;
+        }> | null;
+    };
+};
+export type ActivateRecordsMutationVariables = Exact<{
+    libraryId: Scalars['String'];
+    recordsIds?: InputMaybe<Array<Scalars['String']> | Scalars['String']>;
+    filters?: InputMaybe<Array<RecordFilterInput> | RecordFilterInput>;
+}>;
+export type ActivateRecordsMutation = {
+    activateRecords: Array<{
+        id: string;
+        whoAmI: {
+            id: string;
+            label?: string | null;
+            subLabel?: string | null;
+            color?: string | null;
+            preview?: IPreviewScalar | null;
+            library: {
+                id: string;
+                label?: any | null;
+            };
+        };
+    }>;
+};
+export type CreateEmptyRecordMutationVariables = Exact<{
+    library: Scalars['ID'];
+}>;
+export type CreateEmptyRecordMutation = {
+    createEmptyRecord: {
+        record?: {
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
+                };
+            };
+        } | null;
+        valuesErrors?: Array<{
+            type: string;
+            attribute: string;
+            input?: string | null;
+            message: string;
+        }> | null;
+    };
+};
 export type CreateRecordMutationVariables = Exact<{
     library: Scalars['ID'];
     data?: InputMaybe<CreateRecordDataInput>;
@@ -4306,61 +5148,320 @@ export type RecordFormQuery = {
                                         label?: any | null;
                                     };
                                 };
-                            };
+                            };
+                        }> | null;
+                    }> | null;
+                } | null;
+                permissions: {
+                    access_attribute: boolean;
+                    edit_value: boolean;
+                };
+                versions_conf?: {
+                    versionable: boolean;
+                    profile?: {
+                        id: string;
+                        trees: Array<{
+                            id: string;
+                            label?: any | null;
+                        }>;
+                    } | null;
+                } | null;
+                metadata_fields?: Array<{
+                    id: string;
+                    label?: any | null;
+                    description?: any | null;
+                    type: AttributeType;
+                    format?: AttributeFormat | null;
+                    system: boolean;
+                    readonly: boolean;
+                    multiple_values: boolean;
+                    permissions: {
+                        access_attribute: boolean;
+                        edit_value: boolean;
+                    };
+                    values_list?: {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        dateRangeValues?: Array<{
+                            from?: string | null;
+                            to?: string | null;
+                        }> | null;
+                    } | {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        values?: Array<string> | null;
+                    } | null;
+                    metadata_fields?: Array<{
+                        id: string;
+                    }> | null;
+                }> | null;
+            } | null;
+            settings: Array<{
+                key: string;
+                value: any;
+            }>;
+            joinLibraryContext?: {
+                mandatoryAttribute: {
+                    id: string;
+                    label?: any | null;
+                    description?: any | null;
+                    type: AttributeType;
+                    format?: AttributeFormat | null;
+                    system: boolean;
+                    readonly: boolean;
+                    required: boolean;
+                    multiple_values: boolean;
+                    compute: boolean;
+                    linked_library?: {
+                        id: string;
+                        label?: any | null;
+                        behavior: LibraryBehavior;
+                        permissions?: {
+                            create_record: boolean;
+                        } | null;
+                    } | null;
+                    linkValuesList?: {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        values?: Array<{
+                            id: string;
+                            whoAmI: {
+                                id: string;
+                                label?: string | null;
+                                subLabel?: string | null;
+                                color?: string | null;
+                                preview?: IPreviewScalar | null;
+                                library: {
+                                    id: string;
+                                    label?: any | null;
+                                };
+                            };
+                        }> | null;
+                    } | null;
+                    permissions: {
+                        access_attribute: boolean;
+                        edit_value: boolean;
+                    };
+                    versions_conf?: {
+                        versionable: boolean;
+                        profile?: {
+                            id: string;
+                            trees: Array<{
+                                id: string;
+                                label?: any | null;
+                            }>;
+                        } | null;
+                    } | null;
+                    metadata_fields?: Array<{
+                        id: string;
+                        label?: any | null;
+                        description?: any | null;
+                        type: AttributeType;
+                        format?: AttributeFormat | null;
+                        system: boolean;
+                        readonly: boolean;
+                        multiple_values: boolean;
+                        permissions: {
+                            access_attribute: boolean;
+                            edit_value: boolean;
+                        };
+                        values_list?: {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            dateRangeValues?: Array<{
+                                from?: string | null;
+                                to?: string | null;
+                            }> | null;
+                        } | {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            values?: Array<string> | null;
+                        } | null;
+                        metadata_fields?: Array<{
+                            id: string;
+                        }> | null;
+                    }> | null;
+                } | {
+                    character_limit?: number | null;
+                    id: string;
+                    label?: any | null;
+                    description?: any | null;
+                    type: AttributeType;
+                    format?: AttributeFormat | null;
+                    system: boolean;
+                    readonly: boolean;
+                    required: boolean;
+                    multiple_values: boolean;
+                    compute: boolean;
+                    values_list?: {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        dateRangeValues?: Array<{
+                            from?: string | null;
+                            to?: string | null;
+                        }> | null;
+                    } | {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        values?: Array<string> | null;
+                    } | null;
+                    permissions: {
+                        access_attribute: boolean;
+                        edit_value: boolean;
+                    };
+                    versions_conf?: {
+                        versionable: boolean;
+                        profile?: {
+                            id: string;
+                            trees: Array<{
+                                id: string;
+                                label?: any | null;
+                            }>;
+                        } | null;
+                    } | null;
+                    metadata_fields?: Array<{
+                        id: string;
+                        label?: any | null;
+                        description?: any | null;
+                        type: AttributeType;
+                        format?: AttributeFormat | null;
+                        system: boolean;
+                        readonly: boolean;
+                        multiple_values: boolean;
+                        permissions: {
+                            access_attribute: boolean;
+                            edit_value: boolean;
+                        };
+                        values_list?: {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            dateRangeValues?: Array<{
+                                from?: string | null;
+                                to?: string | null;
+                            }> | null;
+                        } | {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            values?: Array<string> | null;
+                        } | null;
+                        metadata_fields?: Array<{
+                            id: string;
+                        }> | null;
+                    }> | null;
+                } | {
+                    id: string;
+                    label?: any | null;
+                    description?: any | null;
+                    type: AttributeType;
+                    format?: AttributeFormat | null;
+                    system: boolean;
+                    readonly: boolean;
+                    required: boolean;
+                    multiple_values: boolean;
+                    compute: boolean;
+                    linked_tree?: {
+                        id: string;
+                        label?: any | null;
+                    } | null;
+                    treeValuesList?: {
+                        enable: boolean;
+                        allowFreeEntry?: boolean | null;
+                        allowListUpdate?: boolean | null;
+                        values?: Array<{
+                            id: string;
+                            record: {
+                                id: string;
+                                whoAmI: {
+                                    id: string;
+                                    label?: string | null;
+                                    subLabel?: string | null;
+                                    color?: string | null;
+                                    preview?: IPreviewScalar | null;
+                                    library: {
+                                        id: string;
+                                        label?: any | null;
+                                    };
+                                };
+                            };
+                            ancestors?: Array<{
+                                record: {
+                                    id: string;
+                                    whoAmI: {
+                                        id: string;
+                                        label?: string | null;
+                                        subLabel?: string | null;
+                                        color?: string | null;
+                                        preview?: IPreviewScalar | null;
+                                        library: {
+                                            id: string;
+                                            label?: any | null;
+                                        };
+                                    };
+                                };
+                            }> | null;
                         }> | null;
-                    }> | null;
-                } | null;
-                permissions: {
-                    access_attribute: boolean;
-                    edit_value: boolean;
-                };
-                versions_conf?: {
-                    versionable: boolean;
-                    profile?: {
-                        id: string;
-                        trees: Array<{
-                            id: string;
-                            label?: any | null;
-                        }>;
                     } | null;
-                } | null;
-                metadata_fields?: Array<{
-                    id: string;
-                    label?: any | null;
-                    description?: any | null;
-                    type: AttributeType;
-                    format?: AttributeFormat | null;
-                    system: boolean;
-                    readonly: boolean;
-                    multiple_values: boolean;
                     permissions: {
                         access_attribute: boolean;
                         edit_value: boolean;
                     };
-                    values_list?: {
-                        enable: boolean;
-                        allowFreeEntry?: boolean | null;
-                        allowListUpdate?: boolean | null;
-                        dateRangeValues?: Array<{
-                            from?: string | null;
-                            to?: string | null;
-                        }> | null;
-                    } | {
-                        enable: boolean;
-                        allowFreeEntry?: boolean | null;
-                        allowListUpdate?: boolean | null;
-                        values?: Array<string> | null;
+                    versions_conf?: {
+                        versionable: boolean;
+                        profile?: {
+                            id: string;
+                            trees: Array<{
+                                id: string;
+                                label?: any | null;
+                            }>;
+                        } | null;
                     } | null;
                     metadata_fields?: Array<{
                         id: string;
+                        label?: any | null;
+                        description?: any | null;
+                        type: AttributeType;
+                        format?: AttributeFormat | null;
+                        system: boolean;
+                        readonly: boolean;
+                        multiple_values: boolean;
+                        permissions: {
+                            access_attribute: boolean;
+                            edit_value: boolean;
+                        };
+                        values_list?: {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            dateRangeValues?: Array<{
+                                from?: string | null;
+                                to?: string | null;
+                            }> | null;
+                        } | {
+                            enable: boolean;
+                            allowFreeEntry?: boolean | null;
+                            allowListUpdate?: boolean | null;
+                            values?: Array<string> | null;
+                        } | null;
+                        metadata_fields?: Array<{
+                            id: string;
+                        }> | null;
                     }> | null;
-                }> | null;
+                };
             } | null;
-            settings: Array<{
-                key: string;
-                value: any;
-            }>;
         }>;
+        sidePanel?: {
+            enable: boolean;
+            isOpenByDefault?: boolean | null;
+        } | null;
     } | null;
 };
 export type RecordUpdateSubscriptionVariables = Exact<{
@@ -4785,6 +5886,30 @@ export type RecordUpdateSubscription = {
         }>;
     };
 };
+export type GetRecordsFromLibraryQueryVariables = Exact<{
+    libraryId: Scalars['ID'];
+    pagination?: InputMaybe<RecordsPagination>;
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+}>;
+export type GetRecordsFromLibraryQuery = {
+    records: {
+        totalCount?: number | null;
+        list: Array<{
+            id: string;
+            whoAmI: {
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
+                };
+            };
+        }>;
+    };
+};
 export type IndexRecordsMutationVariables = Exact<{
     libraryId: Scalars['String'];
     records?: InputMaybe<Array<Scalars['String']> | Scalars['String']>;
@@ -4792,6 +5917,26 @@ export type IndexRecordsMutationVariables = Exact<{
 export type IndexRecordsMutation = {
     indexRecords: boolean;
 };
+export type PurgeRecordMutationVariables = Exact<{
+    libraryId: Scalars['ID'];
+    recordId: Scalars['ID'];
+}>;
+export type PurgeRecordMutation = {
+    purgeRecord: {
+        id: string;
+        whoAmI: {
+            id: string;
+            label?: string | null;
+            subLabel?: string | null;
+            color?: string | null;
+            preview?: IPreviewScalar | null;
+            library: {
+                id: string;
+                label?: any | null;
+            };
+        };
+    };
+};
 export type CancelTaskMutationVariables = Exact<{
     taskId: Scalars['ID'];
 }>;
@@ -4902,6 +6047,7 @@ export type TreeNodeChildrenQueryVariables = Exact<{
     treeId: Scalars['ID'];
     node?: InputMaybe<Scalars['ID']>;
     pagination?: InputMaybe<Pagination>;
+    childrenAsRecordValuePermissionFilter?: InputMaybe<ChildrenAsRecordValuePermissionFilterInput>;
 }>;
 export type TreeNodeChildrenQuery = {
     treeNodeChildren: {
@@ -4993,159 +6139,16 @@ export type DeleteValueMutation = {
         linkValue?: {
             id: string;
             whoAmI: {
-                id: string;
-                label?: string | null;
-                subLabel?: string | null;
-                color?: string | null;
-                preview?: IPreviewScalar | null;
-                library: {
-                    id: string;
-                    label?: any | null;
-                };
-            };
-        } | null;
-        modified_by?: {
-            id: string;
-            whoAmI: {
-                id: string;
-                label?: string | null;
-                subLabel?: string | null;
-                color?: string | null;
-                preview?: IPreviewScalar | null;
-                library: {
-                    id: string;
-                    label?: any | null;
-                };
-            };
-        } | null;
-        created_by?: {
-            id: string;
-            whoAmI: {
-                id: string;
-                label?: string | null;
-                subLabel?: string | null;
-                color?: string | null;
-                preview?: IPreviewScalar | null;
-                library: {
-                    id: string;
-                    label?: any | null;
-                };
-            };
-        } | null;
-        version?: Array<{
-            treeId: string;
-            treeNode?: {
-                id: string;
-                record: {
-                    id: string;
-                    whoAmI: {
-                        id: string;
-                        label?: string | null;
-                        library: {
-                            id: string;
-                        };
-                    };
-                };
-            } | null;
-        } | null> | null;
-        attribute: {
-            id: string;
-            format?: AttributeFormat | null;
-            type: AttributeType;
-            system: boolean;
-        };
-        metadata?: Array<{
-            name: string;
-            value?: {
-                id_value?: string | null;
-                modified_at?: number | null;
-                created_at?: number | null;
-                payload?: any | null;
-                raw_payload?: any | null;
-                modified_by?: {
-                    id: string;
-                    whoAmI: {
-                        id: string;
-                        label?: string | null;
-                        subLabel?: string | null;
-                        color?: string | null;
-                        preview?: IPreviewScalar | null;
-                        library: {
-                            id: string;
-                            label?: any | null;
-                        };
-                    };
-                } | null;
-                created_by?: {
-                    id: string;
-                    whoAmI: {
-                        id: string;
-                        label?: string | null;
-                        subLabel?: string | null;
-                        color?: string | null;
-                        preview?: IPreviewScalar | null;
-                        library: {
-                            id: string;
-                            label?: any | null;
-                        };
-                    };
-                } | null;
-                version?: Array<{
-                    treeId: string;
-                    treeNode?: {
-                        id: string;
-                        record: {
-                            id: string;
-                            whoAmI: {
-                                id: string;
-                                label?: string | null;
-                                library: {
-                                    id: string;
-                                };
-                            };
-                        };
-                    } | null;
-                } | null> | null;
-            } | null;
-        } | null> | null;
-    } | {
-        id_value?: string | null;
-        isInherited?: boolean | null;
-        isCalculated?: boolean | null;
-        modified_at?: number | null;
-        created_at?: number | null;
-        treeValue?: {
-            id: string;
-            record: {
-                id: string;
-                whoAmI: {
-                    id: string;
-                    label?: string | null;
-                    subLabel?: string | null;
-                    color?: string | null;
-                    preview?: IPreviewScalar | null;
-                    library: {
-                        id: string;
-                        label?: any | null;
-                    };
-                };
-            };
-            ancestors?: Array<{
-                record: {
-                    id: string;
-                    whoAmI: {
-                        id: string;
-                        label?: string | null;
-                        subLabel?: string | null;
-                        color?: string | null;
-                        preview?: IPreviewScalar | null;
-                        library: {
-                            id: string;
-                            label?: any | null;
-                        };
-                    };
+                id: string;
+                label?: string | null;
+                subLabel?: string | null;
+                color?: string | null;
+                preview?: IPreviewScalar | null;
+                library: {
+                    id: string;
+                    label?: any | null;
                 };
-            }> | null;
+            };
         } | null;
         modified_by?: {
             id: string;
@@ -5252,15 +6255,44 @@ export type DeleteValueMutation = {
             } | null;
         } | null> | null;
     } | {
-        payload?: any | null;
-        raw_payload?: any | null;
-        value?: any | null;
-        raw_value?: any | null;
         id_value?: string | null;
         isInherited?: boolean | null;
         isCalculated?: boolean | null;
         modified_at?: number | null;
         created_at?: number | null;
+        treeValue?: {
+            id: string;
+            record: {
+                id: string;
+                whoAmI: {
+                    id: string;
+                    label?: string | null;
+                    subLabel?: string | null;
+                    color?: string | null;
+                    preview?: IPreviewScalar | null;
+                    library: {
+                        id: string;
+                        label?: any | null;
+                    };
+                };
+            };
+            ancestors?: Array<{
+                record: {
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        subLabel?: string | null;
+                        color?: string | null;
+                        preview?: IPreviewScalar | null;
+                        library: {
+                            id: string;
+                            label?: any | null;
+                        };
+                    };
+                };
+            }> | null;
+        } | null;
         modified_by?: {
             id: string;
             whoAmI: {
@@ -5365,24 +6397,16 @@ export type DeleteValueMutation = {
                 } | null> | null;
             } | null;
         } | null> | null;
-    }>;
-};
-export type RunActionsListAndFormatOnValueQueryVariables = Exact<{
-    library: Scalars['ID'];
-    value?: InputMaybe<ValueBatchInput>;
-    version?: InputMaybe<Array<InputMaybe<ValueVersionInput>> | InputMaybe<ValueVersionInput>>;
-}>;
-export type RunActionsListAndFormatOnValueQuery = {
-    runActionsListAndFormatOnValue: Array<{
+    } | {
+        payload?: any | null;
+        raw_payload?: any | null;
+        value?: any | null;
+        raw_value?: any | null;
         id_value?: string | null;
         isInherited?: boolean | null;
         isCalculated?: boolean | null;
         modified_at?: number | null;
         created_at?: number | null;
-        payload?: any | null;
-        raw_payload?: any | null;
-        value?: any | null;
-        raw_value?: any | null;
         modified_by?: {
             id: string;
             whoAmI: {
@@ -6089,6 +7113,98 @@ export type SaveViewMutation = {
         }> | null;
     };
 };
+export type GetAttributesByLibWithPermissionsQueryVariables = Exact<{
+    library: Scalars['String'];
+}>;
+export type GetAttributesByLibWithPermissionsQuery = {
+    attributes?: {
+        list: Array<{
+            id: string;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            label?: any | null;
+            multiple_values: boolean;
+            system: boolean;
+            readonly: boolean;
+            valuesList?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                linkedValues?: Array<{
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        subLabel?: string | null;
+                        color?: string | null;
+                        preview?: IPreviewScalar | null;
+                        library: {
+                            id: string;
+                            label?: any | null;
+                        };
+                    };
+                }> | null;
+            } | null;
+            linked_library?: {
+                id: string;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
+        } | {
+            id: string;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            label?: any | null;
+            multiple_values: boolean;
+            system: boolean;
+            readonly: boolean;
+            embedded_fields?: Array<{
+                id: string;
+                format?: AttributeFormat | null;
+                label?: any | null;
+            } | null> | null;
+            valuesList?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                dateRangeValues?: Array<{
+                    from?: string | null;
+                    to?: string | null;
+                }> | null;
+            } | {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
+        } | {
+            id: string;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            label?: any | null;
+            multiple_values: boolean;
+            system: boolean;
+            readonly: boolean;
+            linked_tree?: {
+                id: string;
+                label?: any | null;
+                libraries: Array<{
+                    library: {
+                        id: string;
+                        label?: any | null;
+                    };
+                }>;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
+        }>;
+    } | null;
+};
 export type ExplorerAttributesQueryVariables = Exact<{
     ids?: InputMaybe<Array<Scalars['ID']> | Scalars['ID']>;
 }>;
@@ -6103,11 +7219,54 @@ export type ExplorerAttributesQuery = {
                 id: string;
                 label?: any | null;
             } | null;
+            valuesList?: {
+                allowFreeEntry?: boolean | null;
+                enable: boolean;
+                linkedValues?: Array<{
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        library: {
+                            id: string;
+                        };
+                    };
+                }> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
+        } | {
+            id: string;
+            type: AttributeType;
+            format?: AttributeFormat | null;
+            label?: any | null;
+            embedded_fields?: Array<{
+                id: string;
+                format?: AttributeFormat | null;
+                label?: any | null;
+            } | null> | null;
+            valuesList?: {
+                enable: boolean;
+                allowFreeEntry?: boolean | null;
+                allowListUpdate?: boolean | null;
+                values?: Array<string> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
         } | {
             id: string;
             type: AttributeType;
             format?: AttributeFormat | null;
             label?: any | null;
+            linked_tree?: {
+                id: string;
+                label?: any | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+            };
         }>;
     } | null;
 };
@@ -6118,15 +7277,50 @@ export type ExplorerLinkAttributeQuery = {
     attributes?: {
         list: Array<{
             label?: any | null;
+            type: AttributeType;
             id: string;
             multiple_values: boolean;
             linked_library?: {
                 id: string;
                 label?: any | null;
             } | null;
+            valuesList?: {
+                allowFreeEntry?: boolean | null;
+                enable: boolean;
+                linkedValues?: Array<{
+                    id: string;
+                    whoAmI: {
+                        id: string;
+                        label?: string | null;
+                        library: {
+                            id: string;
+                        };
+                    };
+                }> | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
+        } | {
+            id: string;
+            multiple_values: boolean;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
         } | {
+            label?: any | null;
             id: string;
             multiple_values: boolean;
+            linked_tree?: {
+                id: string;
+                label?: any | null;
+            } | null;
+            permissions: {
+                access_attribute: boolean;
+                edit_value: boolean;
+            };
         }>;
     } | null;
 };
@@ -6143,6 +7337,7 @@ export type ExplorerLibraryDataQuery = {
         totalCount?: number | null;
         list: Array<{
             id: string;
+            active: boolean;
             whoAmI: {
                 id: string;
                 label?: string | null;
@@ -6154,6 +7349,10 @@ export type ExplorerLibraryDataQuery = {
                     label?: any | null;
                 };
             };
+            permissions: {
+                create_record: boolean;
+                delete_record: boolean;
+            };
             properties: Array<{
                 attributeId: string;
                 attributeProperties: {
@@ -6162,6 +7361,8 @@ export type ExplorerLibraryDataQuery = {
                     type: AttributeType;
                     format?: AttributeFormat | null;
                     multiple_values: boolean;
+                    multi_link_display_option?: MultiDisplayOption | null;
+                    multi_tree_display_option?: MultiDisplayOption | null;
                 };
                 values: Array<{
                     linkPayload?: {
@@ -6242,6 +7443,8 @@ export type ExplorerLinkDataQuery = {
                             type: AttributeType;
                             format?: AttributeFormat | null;
                             multiple_values: boolean;
+                            multi_link_display_option?: MultiDisplayOption | null;
+                            multi_tree_display_option?: MultiDisplayOption | null;
                         };
                         values: Array<{
                             linkPayload?: {
@@ -6308,15 +7511,24 @@ export type GetLibraryAttributesQuery = {
                         label?: any | null;
                     }> | null;
                 } | null;
+                permissions: {
+                    access_attribute: boolean;
+                };
             } | {
                 format?: AttributeFormat | null;
                 id: string;
                 type: AttributeType;
                 label?: any | null;
+                permissions: {
+                    access_attribute: boolean;
+                };
             } | {
                 id: string;
                 type: AttributeType;
                 label?: any | null;
+                permissions: {
+                    access_attribute: boolean;
+                };
             }> | null;
         }>;
     } | null;
@@ -6421,6 +7633,51 @@ export type UpdateViewMutation = {
         }> | null;
     };
 };
+export type GetRecordHistoryQueryVariables = Exact<{
+    record: LogTopicRecordFilterInput;
+    attributeId?: InputMaybe<Scalars['String']>;
+    actions?: InputMaybe<Array<LogAction> | LogAction>;
+    pagination?: InputMaybe<Pagination>;
+}>;
+export type GetRecordHistoryQuery = {
+    logs?: {
+        total: number;
+        logs: Array<{
+            action?: LogAction | null;
+            time: number;
+            topic?: {
+                attribute?: {
+                    id: string;
+                    label?: any | null;
+                    type: AttributeType;
+                    format?: AttributeFormat | null;
+                    multiple_values: boolean;
+                } | null;
+            } | null;
+            user: {
+                id: string;
+                whoAmI: {
+                    id: string;
+                    library: {
+                        id: string;
+                    };
+                };
+                properties: Array<{
+                    attributeId: string;
+                    values: Array<{
+                        payload?: any | null;
+                    }>;
+                }>;
+            };
+            before?: {
+                asString?: string | null;
+            } | null;
+            after?: {
+                asString?: string | null;
+            } | null;
+        }>;
+    } | null;
+};
 export type TreeDataQueryQueryVariables = Exact<{
     treeId: Scalars['ID'];
 }>;
@@ -6446,18 +7703,25 @@ export declare const ValuesVersionDetailsFragmentDoc: Apollo.DocumentNode;
 export declare const ValueDetailsFragmentDoc: Apollo.DocumentNode;
 export declare const StandardValuesListFragmentFragmentDoc: Apollo.DocumentNode;
 export declare const RecordFormAttributeFragmentDoc: Apollo.DocumentNode;
+export declare const JoinLibraryContextFragmentDoc: Apollo.DocumentNode;
 export declare const RecordFormElementFragmentDoc: Apollo.DocumentNode;
 export declare const TreeLightFragmentDoc: Apollo.DocumentNode;
 export declare const TreeDetailsFragmentDoc: Apollo.DocumentNode;
 export declare const TreeNodeChildFragmentDoc: Apollo.DocumentNode;
 export declare const ViewDetailsFilterFragmentDoc: Apollo.DocumentNode;
 export declare const ViewDetailsFragmentDoc: Apollo.DocumentNode;
+export declare const AttributesByLibLinkAttributeWithPermissionsFragmentDoc: Apollo.DocumentNode;
+export declare const AttributesByLibAttributeWithPermissionsFragmentDoc: Apollo.DocumentNode;
 export declare const LinkAttributeDetailsFragmentDoc: Apollo.DocumentNode;
+export declare const TreeAttributeDetailsFragmentDoc: Apollo.DocumentNode;
+export declare const StandardAttributeDetailsFragmentDoc: Apollo.DocumentNode;
 export declare const AttributePropertiesFragmentDoc: Apollo.DocumentNode;
 export declare const PropertyValueFragmentDoc: Apollo.DocumentNode;
 export declare const LinkPropertyFragmentDoc: Apollo.DocumentNode;
 export declare const LibraryAttributeLinkFragmentDoc: Apollo.DocumentNode;
 export declare const LibraryAttributeFragmentDoc: Apollo.DocumentNode;
+export declare const RecordHistoryLogAttributeFragmentDoc: Apollo.DocumentNode;
+export declare const RecordHistoryLogEntryFragmentDoc: Apollo.DocumentNode;
 export declare const CheckApplicationExistenceDocument: Apollo.DocumentNode;
 /**
  * __useCheckApplicationExistenceQuery__
@@ -6484,8 +7748,13 @@ export declare function useCheckApplicationExistenceLazyQuery(baseOptions?: Apol
     id?: InputMaybe<Scalars["ID"]>;
     endpoint?: InputMaybe<Scalars["String"]>;
 }>>;
+export declare function useCheckApplicationExistenceSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<CheckApplicationExistenceQuery, CheckApplicationExistenceQueryVariables>): Apollo.UseSuspenseQueryResult<CheckApplicationExistenceQuery, Exact<{
+    id?: InputMaybe<Scalars["ID"]>;
+    endpoint?: InputMaybe<Scalars["String"]>;
+}>>;
 export type CheckApplicationExistenceQueryHookResult = ReturnType<typeof useCheckApplicationExistenceQuery>;
 export type CheckApplicationExistenceLazyQueryHookResult = ReturnType<typeof useCheckApplicationExistenceLazyQuery>;
+export type CheckApplicationExistenceSuspenseQueryHookResult = ReturnType<typeof useCheckApplicationExistenceSuspenseQuery>;
 export type CheckApplicationExistenceQueryResult = Apollo.QueryResult<CheckApplicationExistenceQuery, CheckApplicationExistenceQueryVariables>;
 export declare const GetApplicationByIdDocument: Apollo.DocumentNode;
 /**
@@ -6510,8 +7779,12 @@ export declare function useGetApplicationByIdQuery(baseOptions: Apollo.QueryHook
 export declare function useGetApplicationByIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetApplicationByIdQuery, GetApplicationByIdQueryVariables>): Apollo.LazyQueryResultTuple<GetApplicationByIdQuery, Exact<{
     id: Scalars["ID"];
 }>>;
+export declare function useGetApplicationByIdSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetApplicationByIdQuery, GetApplicationByIdQueryVariables>): Apollo.UseSuspenseQueryResult<GetApplicationByIdQuery, Exact<{
+    id: Scalars["ID"];
+}>>;
 export type GetApplicationByIdQueryHookResult = ReturnType<typeof useGetApplicationByIdQuery>;
 export type GetApplicationByIdLazyQueryHookResult = ReturnType<typeof useGetApplicationByIdLazyQuery>;
+export type GetApplicationByIdSuspenseQueryHookResult = ReturnType<typeof useGetApplicationByIdSuspenseQuery>;
 export type GetApplicationByIdQueryResult = Apollo.QueryResult<GetApplicationByIdQuery, GetApplicationByIdQueryVariables>;
 export declare const GetApplicationModulesDocument: Apollo.DocumentNode;
 /**
@@ -6535,8 +7808,12 @@ export declare function useGetApplicationModulesQuery(baseOptions?: Apollo.Query
 export declare function useGetApplicationModulesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetApplicationModulesQuery, GetApplicationModulesQueryVariables>): Apollo.LazyQueryResultTuple<GetApplicationModulesQuery, Exact<{
     [key: string]: never;
 }>>;
+export declare function useGetApplicationModulesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetApplicationModulesQuery, GetApplicationModulesQueryVariables>): Apollo.UseSuspenseQueryResult<GetApplicationModulesQuery, Exact<{
+    [key: string]: never;
+}>>;
 export type GetApplicationModulesQueryHookResult = ReturnType<typeof useGetApplicationModulesQuery>;
 export type GetApplicationModulesLazyQueryHookResult = ReturnType<typeof useGetApplicationModulesLazyQuery>;
+export type GetApplicationModulesSuspenseQueryHookResult = ReturnType<typeof useGetApplicationModulesSuspenseQuery>;
 export type GetApplicationModulesQueryResult = Apollo.QueryResult<GetApplicationModulesQuery, GetApplicationModulesQueryVariables>;
 export declare const SaveApplicationDocument: Apollo.DocumentNode;
 export type SaveApplicationMutationFn = Apollo.MutationFunction<SaveApplicationMutation, SaveApplicationMutationVariables>;
@@ -6586,8 +7863,12 @@ export declare function useCheckAttributeExistenceQuery(baseOptions: Apollo.Quer
 export declare function useCheckAttributeExistenceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckAttributeExistenceQuery, CheckAttributeExistenceQueryVariables>): Apollo.LazyQueryResultTuple<CheckAttributeExistenceQuery, Exact<{
     id: Scalars["ID"];
 }>>;
+export declare function useCheckAttributeExistenceSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<CheckAttributeExistenceQuery, CheckAttributeExistenceQueryVariables>): Apollo.UseSuspenseQueryResult<CheckAttributeExistenceQuery, Exact<{
+    id: Scalars["ID"];
+}>>;
 export type CheckAttributeExistenceQueryHookResult = ReturnType<typeof useCheckAttributeExistenceQuery>;
 export type CheckAttributeExistenceLazyQueryHookResult = ReturnType<typeof useCheckAttributeExistenceLazyQuery>;
+export type CheckAttributeExistenceSuspenseQueryHookResult = ReturnType<typeof useCheckAttributeExistenceSuspenseQuery>;
 export type CheckAttributeExistenceQueryResult = Apollo.QueryResult<CheckAttributeExistenceQuery, CheckAttributeExistenceQueryVariables>;
 export declare const DeleteAttributeDocument: Apollo.DocumentNode;
 export type DeleteAttributeMutationFn = Apollo.MutationFunction<DeleteAttributeMutation, DeleteAttributeMutationVariables>;
@@ -6637,8 +7918,12 @@ export declare function useGetAttributeByIdQuery(baseOptions?: Apollo.QueryHookO
 export declare function useGetAttributeByIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAttributeByIdQuery, GetAttributeByIdQueryVariables>): Apollo.LazyQueryResultTuple<GetAttributeByIdQuery, Exact<{
     id?: InputMaybe<Scalars["ID"]>;
 }>>;
+export declare function useGetAttributeByIdSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetAttributeByIdQuery, GetAttributeByIdQueryVariables>): Apollo.UseSuspenseQueryResult<GetAttributeByIdQuery, Exact<{
+    id?: InputMaybe<Scalars["ID"]>;
+}>>;
 export type GetAttributeByIdQueryHookResult = ReturnType<typeof useGetAttributeByIdQuery>;
 export type GetAttributeByIdLazyQueryHookResult = ReturnType<typeof useGetAttributeByIdLazyQuery>;
+export type GetAttributeByIdSuspenseQueryHookResult = ReturnType<typeof useGetAttributeByIdSuspenseQuery>;
 export type GetAttributeByIdQueryResult = Apollo.QueryResult<GetAttributeByIdQuery, GetAttributeByIdQueryVariables>;
 export declare const GetAttributesByLibDocument: Apollo.DocumentNode;
 /**
@@ -6663,8 +7948,12 @@ export declare function useGetAttributesByLibQuery(baseOptions: Apollo.QueryHook
 export declare function useGetAttributesByLibLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAttributesByLibQuery, GetAttributesByLibQueryVariables>): Apollo.LazyQueryResultTuple<GetAttributesByLibQuery, Exact<{
     library: Scalars["String"];
 }>>;
+export declare function useGetAttributesByLibSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetAttributesByLibQuery, GetAttributesByLibQueryVariables>): Apollo.UseSuspenseQueryResult<GetAttributesByLibQuery, Exact<{
+    library: Scalars["String"];
+}>>;
 export type GetAttributesByLibQueryHookResult = ReturnType<typeof useGetAttributesByLibQuery>;
 export type GetAttributesByLibLazyQueryHookResult = ReturnType<typeof useGetAttributesByLibLazyQuery>;
+export type GetAttributesByLibSuspenseQueryHookResult = ReturnType<typeof useGetAttributesByLibSuspenseQuery>;
 export type GetAttributesByLibQueryResult = Apollo.QueryResult<GetAttributesByLibQuery, GetAttributesByLibQueryVariables>;
 export declare const GetAttributesDocument: Apollo.DocumentNode;
 /**
@@ -6695,8 +7984,14 @@ export declare function useGetAttributesLazyQuery(baseOptions?: Apollo.LazyQuery
     sort?: InputMaybe<SortAttributes>;
     filters?: InputMaybe<AttributesFiltersInput>;
 }>>;
+export declare function useGetAttributesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetAttributesQuery, GetAttributesQueryVariables>): Apollo.UseSuspenseQueryResult<GetAttributesQuery, Exact<{
+    pagination?: InputMaybe<Pagination>;
+    sort?: InputMaybe<SortAttributes>;
+    filters?: InputMaybe<AttributesFiltersInput>;
+}>>;
 export type GetAttributesQueryHookResult = ReturnType<typeof useGetAttributesQuery>;
 export type GetAttributesLazyQueryHookResult = ReturnType<typeof useGetAttributesLazyQuery>;
+export type GetAttributesSuspenseQueryHookResult = ReturnType<typeof useGetAttributesSuspenseQuery>;
 export type GetAttributesQueryResult = Apollo.QueryResult<GetAttributesQuery, GetAttributesQueryVariables>;
 export declare const GetVersionProfilesDocument: Apollo.DocumentNode;
 /**
@@ -6724,8 +8019,13 @@ export declare function useGetVersionProfilesLazyQuery(baseOptions?: Apollo.Lazy
     filters?: InputMaybe<VersionProfilesFiltersInput>;
     sort?: InputMaybe<SortVersionProfilesInput>;
 }>>;
+export declare function useGetVersionProfilesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetVersionProfilesQuery, GetVersionProfilesQueryVariables>): Apollo.UseSuspenseQueryResult<GetVersionProfilesQuery, Exact<{
+    filters?: InputMaybe<VersionProfilesFiltersInput>;
+    sort?: InputMaybe<SortVersionProfilesInput>;
+}>>;
 export type GetVersionProfilesQueryHookResult = ReturnType<typeof useGetVersionProfilesQuery>;
 export type GetVersionProfilesLazyQueryHookResult = ReturnType<typeof useGetVersionProfilesLazyQuery>;
+export type GetVersionProfilesSuspenseQueryHookResult = ReturnType<typeof useGetVersionProfilesSuspenseQuery>;
 export type GetVersionProfilesQueryResult = Apollo.QueryResult<GetVersionProfilesQuery, GetVersionProfilesQueryVariables>;
 export declare const GetVersionableAttributesByLibraryDocument: Apollo.DocumentNode;
 /**
@@ -6750,8 +8050,12 @@ export declare function useGetVersionableAttributesByLibraryQuery(baseOptions: A
 export declare function useGetVersionableAttributesByLibraryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVersionableAttributesByLibraryQuery, GetVersionableAttributesByLibraryQueryVariables>): Apollo.LazyQueryResultTuple<GetVersionableAttributesByLibraryQuery, Exact<{
     libraryId: Scalars["String"];
 }>>;
+export declare function useGetVersionableAttributesByLibrarySuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetVersionableAttributesByLibraryQuery, GetVersionableAttributesByLibraryQueryVariables>): Apollo.UseSuspenseQueryResult<GetVersionableAttributesByLibraryQuery, Exact<{
+    libraryId: Scalars["String"];
+}>>;
 export type GetVersionableAttributesByLibraryQueryHookResult = ReturnType<typeof useGetVersionableAttributesByLibraryQuery>;
 export type GetVersionableAttributesByLibraryLazyQueryHookResult = ReturnType<typeof useGetVersionableAttributesByLibraryLazyQuery>;
+export type GetVersionableAttributesByLibrarySuspenseQueryHookResult = ReturnType<typeof useGetVersionableAttributesByLibrarySuspenseQuery>;
 export type GetVersionableAttributesByLibraryQueryResult = Apollo.QueryResult<GetVersionableAttributesByLibraryQuery, GetVersionableAttributesByLibraryQueryVariables>;
 export declare const SaveAttributeDocument: Apollo.DocumentNode;
 export type SaveAttributeMutationFn = Apollo.MutationFunction<SaveAttributeMutation, SaveAttributeMutationVariables>;
@@ -6807,8 +8111,14 @@ export declare function useExportLazyQuery(baseOptions?: Apollo.LazyQueryHookOpt
     attributes?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
     filters?: InputMaybe<Array<RecordFilterInput> | RecordFilterInput>;
 }>>;
+export declare function useExportSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExportQuery, ExportQueryVariables>): Apollo.UseSuspenseQueryResult<ExportQuery, Exact<{
+    library: Scalars["ID"];
+    attributes?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+    filters?: InputMaybe<Array<RecordFilterInput> | RecordFilterInput>;
+}>>;
 export type ExportQueryHookResult = ReturnType<typeof useExportQuery>;
 export type ExportLazyQueryHookResult = ReturnType<typeof useExportLazyQuery>;
+export type ExportSuspenseQueryHookResult = ReturnType<typeof useExportSuspenseQuery>;
 export type ExportQueryResult = Apollo.QueryResult<ExportQuery, ExportQueryVariables>;
 export declare const CreateDirectoryDocument: Apollo.DocumentNode;
 export type CreateDirectoryMutationFn = Apollo.MutationFunction<CreateDirectoryMutation, CreateDirectoryMutationVariables>;
@@ -6898,8 +8208,13 @@ export declare function useGetDirectoryDataLazyQuery(baseOptions?: Apollo.LazyQu
     library: Scalars["ID"];
     directoryId: Scalars["String"];
 }>>;
+export declare function useGetDirectoryDataSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetDirectoryDataQuery, GetDirectoryDataQueryVariables>): Apollo.UseSuspenseQueryResult<GetDirectoryDataQuery, Exact<{
+    library: Scalars["ID"];
+    directoryId: Scalars["String"];
+}>>;
 export type GetDirectoryDataQueryHookResult = ReturnType<typeof useGetDirectoryDataQuery>;
 export type GetDirectoryDataLazyQueryHookResult = ReturnType<typeof useGetDirectoryDataLazyQuery>;
+export type GetDirectoryDataSuspenseQueryHookResult = ReturnType<typeof useGetDirectoryDataSuspenseQuery>;
 export type GetDirectoryDataQueryResult = Apollo.QueryResult<GetDirectoryDataQuery, GetDirectoryDataQueryVariables>;
 export declare const UploadUpdateDocument: Apollo.DocumentNode;
 /**
@@ -7004,8 +8319,12 @@ export declare function useCheckLibraryExistenceQuery(baseOptions?: Apollo.Query
 export declare function useCheckLibraryExistenceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckLibraryExistenceQuery, CheckLibraryExistenceQueryVariables>): Apollo.LazyQueryResultTuple<CheckLibraryExistenceQuery, Exact<{
     id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useCheckLibraryExistenceSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<CheckLibraryExistenceQuery, CheckLibraryExistenceQueryVariables>): Apollo.UseSuspenseQueryResult<CheckLibraryExistenceQuery, Exact<{
+    id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type CheckLibraryExistenceQueryHookResult = ReturnType<typeof useCheckLibraryExistenceQuery>;
 export type CheckLibraryExistenceLazyQueryHookResult = ReturnType<typeof useCheckLibraryExistenceLazyQuery>;
+export type CheckLibraryExistenceSuspenseQueryHookResult = ReturnType<typeof useCheckLibraryExistenceSuspenseQuery>;
 export type CheckLibraryExistenceQueryResult = Apollo.QueryResult<CheckLibraryExistenceQuery, CheckLibraryExistenceQueryVariables>;
 export declare const DeleteLibraryDocument: Apollo.DocumentNode;
 export type DeleteLibraryMutationFn = Apollo.MutationFunction<DeleteLibraryMutation, DeleteLibraryMutationVariables>;
@@ -7054,8 +8373,12 @@ export declare function useGetLibrariesQuery(baseOptions?: Apollo.QueryHookOptio
 export declare function useGetLibrariesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLibrariesQuery, GetLibrariesQueryVariables>): Apollo.LazyQueryResultTuple<GetLibrariesQuery, Exact<{
     [key: string]: never;
 }>>;
+export declare function useGetLibrariesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLibrariesQuery, GetLibrariesQueryVariables>): Apollo.UseSuspenseQueryResult<GetLibrariesQuery, Exact<{
+    [key: string]: never;
+}>>;
 export type GetLibrariesQueryHookResult = ReturnType<typeof useGetLibrariesQuery>;
 export type GetLibrariesLazyQueryHookResult = ReturnType<typeof useGetLibrariesLazyQuery>;
+export type GetLibrariesSuspenseQueryHookResult = ReturnType<typeof useGetLibrariesSuspenseQuery>;
 export type GetLibrariesQueryResult = Apollo.QueryResult<GetLibrariesQuery, GetLibrariesQueryVariables>;
 export declare const GetLibraryByIdDocument: Apollo.DocumentNode;
 /**
@@ -7080,8 +8403,12 @@ export declare function useGetLibraryByIdQuery(baseOptions?: Apollo.QueryHookOpt
 export declare function useGetLibraryByIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLibraryByIdQuery, GetLibraryByIdQueryVariables>): Apollo.LazyQueryResultTuple<GetLibraryByIdQuery, Exact<{
     id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useGetLibraryByIdSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLibraryByIdQuery, GetLibraryByIdQueryVariables>): Apollo.UseSuspenseQueryResult<GetLibraryByIdQuery, Exact<{
+    id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type GetLibraryByIdQueryHookResult = ReturnType<typeof useGetLibraryByIdQuery>;
 export type GetLibraryByIdLazyQueryHookResult = ReturnType<typeof useGetLibraryByIdLazyQuery>;
+export type GetLibraryByIdSuspenseQueryHookResult = ReturnType<typeof useGetLibraryByIdSuspenseQuery>;
 export type GetLibraryByIdQueryResult = Apollo.QueryResult<GetLibraryByIdQuery, GetLibraryByIdQueryVariables>;
 export declare const GetLibraryPermissionsDocument: Apollo.DocumentNode;
 /**
@@ -7106,8 +8433,12 @@ export declare function useGetLibraryPermissionsQuery(baseOptions?: Apollo.Query
 export declare function useGetLibraryPermissionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLibraryPermissionsQuery, GetLibraryPermissionsQueryVariables>): Apollo.LazyQueryResultTuple<GetLibraryPermissionsQuery, Exact<{
     libraryId?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useGetLibraryPermissionsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLibraryPermissionsQuery, GetLibraryPermissionsQueryVariables>): Apollo.UseSuspenseQueryResult<GetLibraryPermissionsQuery, Exact<{
+    libraryId?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type GetLibraryPermissionsQueryHookResult = ReturnType<typeof useGetLibraryPermissionsQuery>;
 export type GetLibraryPermissionsLazyQueryHookResult = ReturnType<typeof useGetLibraryPermissionsLazyQuery>;
+export type GetLibraryPermissionsSuspenseQueryHookResult = ReturnType<typeof useGetLibraryPermissionsSuspenseQuery>;
 export type GetLibraryPermissionsQueryResult = Apollo.QueryResult<GetLibraryPermissionsQuery, GetLibraryPermissionsQueryVariables>;
 export declare const GetLibraryPreviewsSettingsDocument: Apollo.DocumentNode;
 /**
@@ -7132,8 +8463,12 @@ export declare function useGetLibraryPreviewsSettingsQuery(baseOptions: Apollo.Q
 export declare function useGetLibraryPreviewsSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLibraryPreviewsSettingsQuery, GetLibraryPreviewsSettingsQueryVariables>): Apollo.LazyQueryResultTuple<GetLibraryPreviewsSettingsQuery, Exact<{
     id: Scalars["ID"];
 }>>;
+export declare function useGetLibraryPreviewsSettingsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLibraryPreviewsSettingsQuery, GetLibraryPreviewsSettingsQueryVariables>): Apollo.UseSuspenseQueryResult<GetLibraryPreviewsSettingsQuery, Exact<{
+    id: Scalars["ID"];
+}>>;
 export type GetLibraryPreviewsSettingsQueryHookResult = ReturnType<typeof useGetLibraryPreviewsSettingsQuery>;
 export type GetLibraryPreviewsSettingsLazyQueryHookResult = ReturnType<typeof useGetLibraryPreviewsSettingsLazyQuery>;
+export type GetLibraryPreviewsSettingsSuspenseQueryHookResult = ReturnType<typeof useGetLibraryPreviewsSettingsSuspenseQuery>;
 export type GetLibraryPreviewsSettingsQueryResult = Apollo.QueryResult<GetLibraryPreviewsSettingsQuery, GetLibraryPreviewsSettingsQueryVariables>;
 export declare const SaveLibraryDocument: Apollo.DocumentNode;
 export type SaveLibraryMutationFn = Apollo.MutationFunction<SaveLibraryMutation, SaveLibraryMutationVariables>;
@@ -7192,9 +8527,99 @@ export declare function useIsAllowedLazyQuery(baseOptions?: Apollo.LazyQueryHook
     applyTo?: InputMaybe<Scalars["ID"]>;
     target?: InputMaybe<PermissionTarget>;
 }>>;
+export declare function useIsAllowedSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<IsAllowedQuery, IsAllowedQueryVariables>): Apollo.UseSuspenseQueryResult<IsAllowedQuery, Exact<{
+    type: PermissionTypes;
+    actions: Array<PermissionsActions> | PermissionsActions;
+    applyTo?: InputMaybe<Scalars["ID"]>;
+    target?: InputMaybe<PermissionTarget>;
+}>>;
 export type IsAllowedQueryHookResult = ReturnType<typeof useIsAllowedQuery>;
 export type IsAllowedLazyQueryHookResult = ReturnType<typeof useIsAllowedLazyQuery>;
+export type IsAllowedSuspenseQueryHookResult = ReturnType<typeof useIsAllowedSuspenseQuery>;
 export type IsAllowedQueryResult = Apollo.QueryResult<IsAllowedQuery, IsAllowedQueryVariables>;
+export declare const ActivateNewRecordDocument: Apollo.DocumentNode;
+export type ActivateNewRecordMutationFn = Apollo.MutationFunction<ActivateNewRecordMutation, ActivateNewRecordMutationVariables>;
+/**
+ * __useActivateNewRecordMutation__
+ *
+ * To run a mutation, you first call `useActivateNewRecordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useActivateNewRecordMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [activateNewRecordMutation, { data, loading, error }] = useActivateNewRecordMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      recordId: // value for 'recordId'
+ *      formId: // value for 'formId'
+ *   },
+ * });
+ */
+export declare function useActivateNewRecordMutation(baseOptions?: Apollo.MutationHookOptions<ActivateNewRecordMutation, ActivateNewRecordMutationVariables>): Apollo.MutationTuple<ActivateNewRecordMutation, Exact<{
+    libraryId: Scalars["ID"];
+    recordId: Scalars["ID"];
+    formId?: InputMaybe<Scalars["String"]>;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ActivateNewRecordMutationHookResult = ReturnType<typeof useActivateNewRecordMutation>;
+export type ActivateNewRecordMutationResult = Apollo.MutationResult<ActivateNewRecordMutation>;
+export type ActivateNewRecordMutationOptions = Apollo.BaseMutationOptions<ActivateNewRecordMutation, ActivateNewRecordMutationVariables>;
+export declare const ActivateRecordsDocument: Apollo.DocumentNode;
+export type ActivateRecordsMutationFn = Apollo.MutationFunction<ActivateRecordsMutation, ActivateRecordsMutationVariables>;
+/**
+ * __useActivateRecordsMutation__
+ *
+ * To run a mutation, you first call `useActivateRecordsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useActivateRecordsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [activateRecordsMutation, { data, loading, error }] = useActivateRecordsMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      recordsIds: // value for 'recordsIds'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export declare function useActivateRecordsMutation(baseOptions?: Apollo.MutationHookOptions<ActivateRecordsMutation, ActivateRecordsMutationVariables>): Apollo.MutationTuple<ActivateRecordsMutation, Exact<{
+    libraryId: Scalars["String"];
+    recordsIds?: InputMaybe<Array<Scalars["String"]> | Scalars["String"]>;
+    filters?: InputMaybe<Array<RecordFilterInput> | RecordFilterInput>;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ActivateRecordsMutationHookResult = ReturnType<typeof useActivateRecordsMutation>;
+export type ActivateRecordsMutationResult = Apollo.MutationResult<ActivateRecordsMutation>;
+export type ActivateRecordsMutationOptions = Apollo.BaseMutationOptions<ActivateRecordsMutation, ActivateRecordsMutationVariables>;
+export declare const CreateEmptyRecordDocument: Apollo.DocumentNode;
+export type CreateEmptyRecordMutationFn = Apollo.MutationFunction<CreateEmptyRecordMutation, CreateEmptyRecordMutationVariables>;
+/**
+ * __useCreateEmptyRecordMutation__
+ *
+ * To run a mutation, you first call `useCreateEmptyRecordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateEmptyRecordMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createEmptyRecordMutation, { data, loading, error }] = useCreateEmptyRecordMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *   },
+ * });
+ */
+export declare function useCreateEmptyRecordMutation(baseOptions?: Apollo.MutationHookOptions<CreateEmptyRecordMutation, CreateEmptyRecordMutationVariables>): Apollo.MutationTuple<CreateEmptyRecordMutation, Exact<{
+    library: Scalars["ID"];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateEmptyRecordMutationHookResult = ReturnType<typeof useCreateEmptyRecordMutation>;
+export type CreateEmptyRecordMutationResult = Apollo.MutationResult<CreateEmptyRecordMutation>;
+export type CreateEmptyRecordMutationOptions = Apollo.BaseMutationOptions<CreateEmptyRecordMutation, CreateEmptyRecordMutationVariables>;
 export declare const CreateRecordDocument: Apollo.DocumentNode;
 export type CreateRecordMutationFn = Apollo.MutationFunction<CreateRecordMutation, CreateRecordMutationVariables>;
 /**
@@ -7280,8 +8705,14 @@ export declare function useDoesFileExistAsChildLazyQuery(baseOptions?: Apollo.La
     treeId: Scalars["ID"];
     filename: Scalars["String"];
 }>>;
+export declare function useDoesFileExistAsChildSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<DoesFileExistAsChildQuery, DoesFileExistAsChildQueryVariables>): Apollo.UseSuspenseQueryResult<DoesFileExistAsChildQuery, Exact<{
+    parentNode?: InputMaybe<Scalars["ID"]>;
+    treeId: Scalars["ID"];
+    filename: Scalars["String"];
+}>>;
 export type DoesFileExistAsChildQueryHookResult = ReturnType<typeof useDoesFileExistAsChildQuery>;
 export type DoesFileExistAsChildLazyQueryHookResult = ReturnType<typeof useDoesFileExistAsChildLazyQuery>;
+export type DoesFileExistAsChildSuspenseQueryHookResult = ReturnType<typeof useDoesFileExistAsChildSuspenseQuery>;
 export type DoesFileExistAsChildQueryResult = Apollo.QueryResult<DoesFileExistAsChildQuery, DoesFileExistAsChildQueryVariables>;
 export declare const GetFileDataDocument: Apollo.DocumentNode;
 /**
@@ -7312,8 +8743,14 @@ export declare function useGetFileDataLazyQuery(baseOptions?: Apollo.LazyQueryHo
     fileId: Scalars["String"];
     previewsStatusAttribute: Scalars["ID"];
 }>>;
+export declare function useGetFileDataSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetFileDataQuery, GetFileDataQueryVariables>): Apollo.UseSuspenseQueryResult<GetFileDataQuery, Exact<{
+    library: Scalars["ID"];
+    fileId: Scalars["String"];
+    previewsStatusAttribute: Scalars["ID"];
+}>>;
 export type GetFileDataQueryHookResult = ReturnType<typeof useGetFileDataQuery>;
 export type GetFileDataLazyQueryHookResult = ReturnType<typeof useGetFileDataLazyQuery>;
+export type GetFileDataSuspenseQueryHookResult = ReturnType<typeof useGetFileDataSuspenseQuery>;
 export type GetFileDataQueryResult = Apollo.QueryResult<GetFileDataQuery, GetFileDataQueryVariables>;
 export declare const RecordFormDocument: Apollo.DocumentNode;
 /**
@@ -7347,8 +8784,15 @@ export declare function useRecordFormLazyQuery(baseOptions?: Apollo.LazyQueryHoo
     recordId?: InputMaybe<Scalars["String"]>;
     version?: InputMaybe<Array<ValueVersionInput> | ValueVersionInput>;
 }>>;
+export declare function useRecordFormSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<RecordFormQuery, RecordFormQueryVariables>): Apollo.UseSuspenseQueryResult<RecordFormQuery, Exact<{
+    libraryId: Scalars["String"];
+    formId: Scalars["String"];
+    recordId?: InputMaybe<Scalars["String"]>;
+    version?: InputMaybe<Array<ValueVersionInput> | ValueVersionInput>;
+}>>;
 export type RecordFormQueryHookResult = ReturnType<typeof useRecordFormQuery>;
 export type RecordFormLazyQueryHookResult = ReturnType<typeof useRecordFormLazyQuery>;
+export type RecordFormSuspenseQueryHookResult = ReturnType<typeof useRecordFormSuspenseQuery>;
 export type RecordFormQueryResult = Apollo.QueryResult<RecordFormQuery, RecordFormQueryVariables>;
 export declare const RecordUpdateDocument: Apollo.DocumentNode;
 /**
@@ -7372,6 +8816,44 @@ export declare function useRecordUpdateSubscription(baseOptions?: Apollo.Subscri
 }>>;
 export type RecordUpdateSubscriptionHookResult = ReturnType<typeof useRecordUpdateSubscription>;
 export type RecordUpdateSubscriptionResult = Apollo.SubscriptionResult<RecordUpdateSubscription>;
+export declare const GetRecordsFromLibraryDocument: Apollo.DocumentNode;
+/**
+ * __useGetRecordsFromLibraryQuery__
+ *
+ * To run a query within a React component, call `useGetRecordsFromLibraryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRecordsFromLibraryQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRecordsFromLibraryQuery({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      pagination: // value for 'pagination'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export declare function useGetRecordsFromLibraryQuery(baseOptions: Apollo.QueryHookOptions<GetRecordsFromLibraryQuery, GetRecordsFromLibraryQueryVariables>): Apollo.QueryResult<GetRecordsFromLibraryQuery, Exact<{
+    libraryId: Scalars["ID"];
+    pagination?: InputMaybe<RecordsPagination>;
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+}>>;
+export declare function useGetRecordsFromLibraryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetRecordsFromLibraryQuery, GetRecordsFromLibraryQueryVariables>): Apollo.LazyQueryResultTuple<GetRecordsFromLibraryQuery, Exact<{
+    libraryId: Scalars["ID"];
+    pagination?: InputMaybe<RecordsPagination>;
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+}>>;
+export declare function useGetRecordsFromLibrarySuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetRecordsFromLibraryQuery, GetRecordsFromLibraryQueryVariables>): Apollo.UseSuspenseQueryResult<GetRecordsFromLibraryQuery, Exact<{
+    libraryId: Scalars["ID"];
+    pagination?: InputMaybe<RecordsPagination>;
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+}>>;
+export type GetRecordsFromLibraryQueryHookResult = ReturnType<typeof useGetRecordsFromLibraryQuery>;
+export type GetRecordsFromLibraryLazyQueryHookResult = ReturnType<typeof useGetRecordsFromLibraryLazyQuery>;
+export type GetRecordsFromLibrarySuspenseQueryHookResult = ReturnType<typeof useGetRecordsFromLibrarySuspenseQuery>;
+export type GetRecordsFromLibraryQueryResult = Apollo.QueryResult<GetRecordsFromLibraryQuery, GetRecordsFromLibraryQueryVariables>;
 export declare const IndexRecordsDocument: Apollo.DocumentNode;
 export type IndexRecordsMutationFn = Apollo.MutationFunction<IndexRecordsMutation, IndexRecordsMutationVariables>;
 /**
@@ -7399,6 +8881,33 @@ export declare function useIndexRecordsMutation(baseOptions?: Apollo.MutationHoo
 export type IndexRecordsMutationHookResult = ReturnType<typeof useIndexRecordsMutation>;
 export type IndexRecordsMutationResult = Apollo.MutationResult<IndexRecordsMutation>;
 export type IndexRecordsMutationOptions = Apollo.BaseMutationOptions<IndexRecordsMutation, IndexRecordsMutationVariables>;
+export declare const PurgeRecordDocument: Apollo.DocumentNode;
+export type PurgeRecordMutationFn = Apollo.MutationFunction<PurgeRecordMutation, PurgeRecordMutationVariables>;
+/**
+ * __usePurgeRecordMutation__
+ *
+ * To run a mutation, you first call `usePurgeRecordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `usePurgeRecordMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [purgeRecordMutation, { data, loading, error }] = usePurgeRecordMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      recordId: // value for 'recordId'
+ *   },
+ * });
+ */
+export declare function usePurgeRecordMutation(baseOptions?: Apollo.MutationHookOptions<PurgeRecordMutation, PurgeRecordMutationVariables>): Apollo.MutationTuple<PurgeRecordMutation, Exact<{
+    libraryId: Scalars["ID"];
+    recordId: Scalars["ID"];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type PurgeRecordMutationHookResult = ReturnType<typeof usePurgeRecordMutation>;
+export type PurgeRecordMutationResult = Apollo.MutationResult<PurgeRecordMutation>;
+export type PurgeRecordMutationOptions = Apollo.BaseMutationOptions<PurgeRecordMutation, PurgeRecordMutationVariables>;
 export declare const CancelTaskDocument: Apollo.DocumentNode;
 export type CancelTaskMutationFn = Apollo.MutationFunction<CancelTaskMutation, CancelTaskMutationVariables>;
 /**
@@ -7447,8 +8956,12 @@ export declare function useCheckTreeExistenceQuery(baseOptions?: Apollo.QueryHoo
 export declare function useCheckTreeExistenceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckTreeExistenceQuery, CheckTreeExistenceQueryVariables>): Apollo.LazyQueryResultTuple<CheckTreeExistenceQuery, Exact<{
     id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useCheckTreeExistenceSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<CheckTreeExistenceQuery, CheckTreeExistenceQueryVariables>): Apollo.UseSuspenseQueryResult<CheckTreeExistenceQuery, Exact<{
+    id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type CheckTreeExistenceQueryHookResult = ReturnType<typeof useCheckTreeExistenceQuery>;
 export type CheckTreeExistenceLazyQueryHookResult = ReturnType<typeof useCheckTreeExistenceLazyQuery>;
+export type CheckTreeExistenceSuspenseQueryHookResult = ReturnType<typeof useCheckTreeExistenceSuspenseQuery>;
 export type CheckTreeExistenceQueryResult = Apollo.QueryResult<CheckTreeExistenceQuery, CheckTreeExistenceQueryVariables>;
 export declare const DeleteTreeDocument: Apollo.DocumentNode;
 export type DeleteTreeMutationFn = Apollo.MutationFunction<DeleteTreeMutation, DeleteTreeMutationVariables>;
@@ -7498,8 +9011,12 @@ export declare function useGetTreeByIdQuery(baseOptions?: Apollo.QueryHookOption
 export declare function useGetTreeByIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTreeByIdQuery, GetTreeByIdQueryVariables>): Apollo.LazyQueryResultTuple<GetTreeByIdQuery, Exact<{
     id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useGetTreeByIdSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetTreeByIdQuery, GetTreeByIdQueryVariables>): Apollo.UseSuspenseQueryResult<GetTreeByIdQuery, Exact<{
+    id?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type GetTreeByIdQueryHookResult = ReturnType<typeof useGetTreeByIdQuery>;
 export type GetTreeByIdLazyQueryHookResult = ReturnType<typeof useGetTreeByIdLazyQuery>;
+export type GetTreeByIdSuspenseQueryHookResult = ReturnType<typeof useGetTreeByIdSuspenseQuery>;
 export type GetTreeByIdQueryResult = Apollo.QueryResult<GetTreeByIdQuery, GetTreeByIdQueryVariables>;
 export declare const GetTreeLibrariesDocument: Apollo.DocumentNode;
 /**
@@ -7527,8 +9044,13 @@ export declare function useGetTreeLibrariesLazyQuery(baseOptions?: Apollo.LazyQu
     treeId?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
     library?: InputMaybe<Scalars["String"]>;
 }>>;
+export declare function useGetTreeLibrariesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetTreeLibrariesQuery, GetTreeLibrariesQueryVariables>): Apollo.UseSuspenseQueryResult<GetTreeLibrariesQuery, Exact<{
+    treeId?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+    library?: InputMaybe<Scalars["String"]>;
+}>>;
 export type GetTreeLibrariesQueryHookResult = ReturnType<typeof useGetTreeLibrariesQuery>;
 export type GetTreeLibrariesLazyQueryHookResult = ReturnType<typeof useGetTreeLibrariesLazyQuery>;
+export type GetTreeLibrariesSuspenseQueryHookResult = ReturnType<typeof useGetTreeLibrariesSuspenseQuery>;
 export type GetTreeLibrariesQueryResult = Apollo.QueryResult<GetTreeLibrariesQuery, GetTreeLibrariesQueryVariables>;
 export declare const GetTreesDocument: Apollo.DocumentNode;
 /**
@@ -7552,8 +9074,12 @@ export declare function useGetTreesQuery(baseOptions?: Apollo.QueryHookOptions<G
 export declare function useGetTreesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTreesQuery, GetTreesQueryVariables>): Apollo.LazyQueryResultTuple<GetTreesQuery, Exact<{
     [key: string]: never;
 }>>;
+export declare function useGetTreesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetTreesQuery, GetTreesQueryVariables>): Apollo.UseSuspenseQueryResult<GetTreesQuery, Exact<{
+    [key: string]: never;
+}>>;
 export type GetTreesQueryHookResult = ReturnType<typeof useGetTreesQuery>;
 export type GetTreesLazyQueryHookResult = ReturnType<typeof useGetTreesLazyQuery>;
+export type GetTreesSuspenseQueryHookResult = ReturnType<typeof useGetTreesSuspenseQuery>;
 export type GetTreesQueryResult = Apollo.QueryResult<GetTreesQuery, GetTreesQueryVariables>;
 export declare const SaveTreeDocument: Apollo.DocumentNode;
 export type SaveTreeMutationFn = Apollo.MutationFunction<SaveTreeMutation, SaveTreeMutationVariables>;
@@ -7596,6 +9122,7 @@ export declare const TreeNodeChildrenDocument: Apollo.DocumentNode;
  *      treeId: // value for 'treeId'
  *      node: // value for 'node'
  *      pagination: // value for 'pagination'
+ *      childrenAsRecordValuePermissionFilter: // value for 'childrenAsRecordValuePermissionFilter'
  *   },
  * });
  */
@@ -7603,14 +9130,23 @@ export declare function useTreeNodeChildrenQuery(baseOptions: Apollo.QueryHookOp
     treeId: Scalars["ID"];
     node?: InputMaybe<Scalars["ID"]>;
     pagination?: InputMaybe<Pagination>;
+    childrenAsRecordValuePermissionFilter?: InputMaybe<ChildrenAsRecordValuePermissionFilterInput>;
 }>>;
 export declare function useTreeNodeChildrenLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TreeNodeChildrenQuery, TreeNodeChildrenQueryVariables>): Apollo.LazyQueryResultTuple<TreeNodeChildrenQuery, Exact<{
     treeId: Scalars["ID"];
     node?: InputMaybe<Scalars["ID"]>;
     pagination?: InputMaybe<Pagination>;
+    childrenAsRecordValuePermissionFilter?: InputMaybe<ChildrenAsRecordValuePermissionFilterInput>;
+}>>;
+export declare function useTreeNodeChildrenSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<TreeNodeChildrenQuery, TreeNodeChildrenQueryVariables>): Apollo.UseSuspenseQueryResult<TreeNodeChildrenQuery, Exact<{
+    treeId: Scalars["ID"];
+    node?: InputMaybe<Scalars["ID"]>;
+    pagination?: InputMaybe<Pagination>;
+    childrenAsRecordValuePermissionFilter?: InputMaybe<ChildrenAsRecordValuePermissionFilterInput>;
 }>>;
 export type TreeNodeChildrenQueryHookResult = ReturnType<typeof useTreeNodeChildrenQuery>;
 export type TreeNodeChildrenLazyQueryHookResult = ReturnType<typeof useTreeNodeChildrenLazyQuery>;
+export type TreeNodeChildrenSuspenseQueryHookResult = ReturnType<typeof useTreeNodeChildrenSuspenseQuery>;
 export type TreeNodeChildrenQueryResult = Apollo.QueryResult<TreeNodeChildrenQuery, TreeNodeChildrenQueryVariables>;
 export declare const GetUserDataDocument: Apollo.DocumentNode;
 /**
@@ -7638,8 +9174,13 @@ export declare function useGetUserDataLazyQuery(baseOptions?: Apollo.LazyQueryHo
     keys: Array<Scalars["String"]> | Scalars["String"];
     global?: InputMaybe<Scalars["Boolean"]>;
 }>>;
+export declare function useGetUserDataSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetUserDataQuery, GetUserDataQueryVariables>): Apollo.UseSuspenseQueryResult<GetUserDataQuery, Exact<{
+    keys: Array<Scalars["String"]> | Scalars["String"];
+    global?: InputMaybe<Scalars["Boolean"]>;
+}>>;
 export type GetUserDataQueryHookResult = ReturnType<typeof useGetUserDataQuery>;
 export type GetUserDataLazyQueryHookResult = ReturnType<typeof useGetUserDataLazyQuery>;
+export type GetUserDataSuspenseQueryHookResult = ReturnType<typeof useGetUserDataSuspenseQuery>;
 export type GetUserDataQueryResult = Apollo.QueryResult<GetUserDataQuery, GetUserDataQueryVariables>;
 export declare const SaveUserDataDocument: Apollo.DocumentNode;
 export type SaveUserDataMutationFn = Apollo.MutationFunction<SaveUserDataMutation, SaveUserDataMutationVariables>;
@@ -7701,38 +9242,6 @@ export declare function useDeleteValueMutation(baseOptions?: Apollo.MutationHook
 export type DeleteValueMutationHookResult = ReturnType<typeof useDeleteValueMutation>;
 export type DeleteValueMutationResult = Apollo.MutationResult<DeleteValueMutation>;
 export type DeleteValueMutationOptions = Apollo.BaseMutationOptions<DeleteValueMutation, DeleteValueMutationVariables>;
-export declare const RunActionsListAndFormatOnValueDocument: Apollo.DocumentNode;
-/**
- * __useRunActionsListAndFormatOnValueQuery__
- *
- * To run a query within a React component, call `useRunActionsListAndFormatOnValueQuery` and pass it any options that fit your needs.
- * When your component renders, `useRunActionsListAndFormatOnValueQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useRunActionsListAndFormatOnValueQuery({
- *   variables: {
- *      library: // value for 'library'
- *      value: // value for 'value'
- *      version: // value for 'version'
- *   },
- * });
- */
-export declare function useRunActionsListAndFormatOnValueQuery(baseOptions: Apollo.QueryHookOptions<RunActionsListAndFormatOnValueQuery, RunActionsListAndFormatOnValueQueryVariables>): Apollo.QueryResult<RunActionsListAndFormatOnValueQuery, Exact<{
-    library: Scalars["ID"];
-    value?: InputMaybe<ValueBatchInput>;
-    version?: InputMaybe<Array<InputMaybe<ValueVersionInput>> | InputMaybe<ValueVersionInput>>;
-}>>;
-export declare function useRunActionsListAndFormatOnValueLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RunActionsListAndFormatOnValueQuery, RunActionsListAndFormatOnValueQueryVariables>): Apollo.LazyQueryResultTuple<RunActionsListAndFormatOnValueQuery, Exact<{
-    library: Scalars["ID"];
-    value?: InputMaybe<ValueBatchInput>;
-    version?: InputMaybe<Array<InputMaybe<ValueVersionInput>> | InputMaybe<ValueVersionInput>>;
-}>>;
-export type RunActionsListAndFormatOnValueQueryHookResult = ReturnType<typeof useRunActionsListAndFormatOnValueQuery>;
-export type RunActionsListAndFormatOnValueLazyQueryHookResult = ReturnType<typeof useRunActionsListAndFormatOnValueLazyQuery>;
-export type RunActionsListAndFormatOnValueQueryResult = Apollo.QueryResult<RunActionsListAndFormatOnValueQuery, RunActionsListAndFormatOnValueQueryVariables>;
 export declare const SaveValueBatchDocument: Apollo.DocumentNode;
 export type SaveValueBatchMutationFn = Apollo.MutationFunction<SaveValueBatchMutation, SaveValueBatchMutationVariables>;
 /**
@@ -7814,8 +9323,12 @@ export declare function useGetViewQuery(baseOptions: Apollo.QueryHookOptions<Get
 export declare function useGetViewLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetViewQuery, GetViewQueryVariables>): Apollo.LazyQueryResultTuple<GetViewQuery, Exact<{
     viewId: Scalars["String"];
 }>>;
+export declare function useGetViewSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetViewQuery, GetViewQueryVariables>): Apollo.UseSuspenseQueryResult<GetViewQuery, Exact<{
+    viewId: Scalars["String"];
+}>>;
 export type GetViewQueryHookResult = ReturnType<typeof useGetViewQuery>;
 export type GetViewLazyQueryHookResult = ReturnType<typeof useGetViewLazyQuery>;
+export type GetViewSuspenseQueryHookResult = ReturnType<typeof useGetViewSuspenseQuery>;
 export type GetViewQueryResult = Apollo.QueryResult<GetViewQuery, GetViewQueryVariables>;
 export declare const GetViewsListDocument: Apollo.DocumentNode;
 /**
@@ -7840,8 +9353,12 @@ export declare function useGetViewsListQuery(baseOptions: Apollo.QueryHookOption
 export declare function useGetViewsListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetViewsListQuery, GetViewsListQueryVariables>): Apollo.LazyQueryResultTuple<GetViewsListQuery, Exact<{
     libraryId: Scalars["String"];
 }>>;
+export declare function useGetViewsListSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetViewsListQuery, GetViewsListQueryVariables>): Apollo.UseSuspenseQueryResult<GetViewsListQuery, Exact<{
+    libraryId: Scalars["String"];
+}>>;
 export type GetViewsListQueryHookResult = ReturnType<typeof useGetViewsListQuery>;
 export type GetViewsListLazyQueryHookResult = ReturnType<typeof useGetViewsListLazyQuery>;
+export type GetViewsListSuspenseQueryHookResult = ReturnType<typeof useGetViewsListSuspenseQuery>;
 export type GetViewsListQueryResult = Apollo.QueryResult<GetViewsListQuery, GetViewsListQueryVariables>;
 export declare const SaveViewDocument: Apollo.DocumentNode;
 export type SaveViewMutationFn = Apollo.MutationFunction<SaveViewMutation, SaveViewMutationVariables>;
@@ -7868,6 +9385,36 @@ export declare function useSaveViewMutation(baseOptions?: Apollo.MutationHookOpt
 export type SaveViewMutationHookResult = ReturnType<typeof useSaveViewMutation>;
 export type SaveViewMutationResult = Apollo.MutationResult<SaveViewMutation>;
 export type SaveViewMutationOptions = Apollo.BaseMutationOptions<SaveViewMutation, SaveViewMutationVariables>;
+export declare const GetAttributesByLibWithPermissionsDocument: Apollo.DocumentNode;
+/**
+ * __useGetAttributesByLibWithPermissionsQuery__
+ *
+ * To run a query within a React component, call `useGetAttributesByLibWithPermissionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAttributesByLibWithPermissionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetAttributesByLibWithPermissionsQuery({
+ *   variables: {
+ *      library: // value for 'library'
+ *   },
+ * });
+ */
+export declare function useGetAttributesByLibWithPermissionsQuery(baseOptions: Apollo.QueryHookOptions<GetAttributesByLibWithPermissionsQuery, GetAttributesByLibWithPermissionsQueryVariables>): Apollo.QueryResult<GetAttributesByLibWithPermissionsQuery, Exact<{
+    library: Scalars["String"];
+}>>;
+export declare function useGetAttributesByLibWithPermissionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAttributesByLibWithPermissionsQuery, GetAttributesByLibWithPermissionsQueryVariables>): Apollo.LazyQueryResultTuple<GetAttributesByLibWithPermissionsQuery, Exact<{
+    library: Scalars["String"];
+}>>;
+export declare function useGetAttributesByLibWithPermissionsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetAttributesByLibWithPermissionsQuery, GetAttributesByLibWithPermissionsQueryVariables>): Apollo.UseSuspenseQueryResult<GetAttributesByLibWithPermissionsQuery, Exact<{
+    library: Scalars["String"];
+}>>;
+export type GetAttributesByLibWithPermissionsQueryHookResult = ReturnType<typeof useGetAttributesByLibWithPermissionsQuery>;
+export type GetAttributesByLibWithPermissionsLazyQueryHookResult = ReturnType<typeof useGetAttributesByLibWithPermissionsLazyQuery>;
+export type GetAttributesByLibWithPermissionsSuspenseQueryHookResult = ReturnType<typeof useGetAttributesByLibWithPermissionsSuspenseQuery>;
+export type GetAttributesByLibWithPermissionsQueryResult = Apollo.QueryResult<GetAttributesByLibWithPermissionsQuery, GetAttributesByLibWithPermissionsQueryVariables>;
 export declare const ExplorerAttributesDocument: Apollo.DocumentNode;
 /**
  * __useExplorerAttributesQuery__
@@ -7891,8 +9438,12 @@ export declare function useExplorerAttributesQuery(baseOptions?: Apollo.QueryHoo
 export declare function useExplorerAttributesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExplorerAttributesQuery, ExplorerAttributesQueryVariables>): Apollo.LazyQueryResultTuple<ExplorerAttributesQuery, Exact<{
     ids?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
 }>>;
+export declare function useExplorerAttributesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerAttributesQuery, ExplorerAttributesQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerAttributesQuery, Exact<{
+    ids?: InputMaybe<Array<Scalars["ID"]> | Scalars["ID"]>;
+}>>;
 export type ExplorerAttributesQueryHookResult = ReturnType<typeof useExplorerAttributesQuery>;
 export type ExplorerAttributesLazyQueryHookResult = ReturnType<typeof useExplorerAttributesLazyQuery>;
+export type ExplorerAttributesSuspenseQueryHookResult = ReturnType<typeof useExplorerAttributesSuspenseQuery>;
 export type ExplorerAttributesQueryResult = Apollo.QueryResult<ExplorerAttributesQuery, ExplorerAttributesQueryVariables>;
 export declare const ExplorerLinkAttributeDocument: Apollo.DocumentNode;
 /**
@@ -7917,8 +9468,12 @@ export declare function useExplorerLinkAttributeQuery(baseOptions: Apollo.QueryH
 export declare function useExplorerLinkAttributeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExplorerLinkAttributeQuery, ExplorerLinkAttributeQueryVariables>): Apollo.LazyQueryResultTuple<ExplorerLinkAttributeQuery, Exact<{
     id: Scalars["ID"];
 }>>;
+export declare function useExplorerLinkAttributeSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerLinkAttributeQuery, ExplorerLinkAttributeQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerLinkAttributeQuery, Exact<{
+    id: Scalars["ID"];
+}>>;
 export type ExplorerLinkAttributeQueryHookResult = ReturnType<typeof useExplorerLinkAttributeQuery>;
 export type ExplorerLinkAttributeLazyQueryHookResult = ReturnType<typeof useExplorerLinkAttributeLazyQuery>;
+export type ExplorerLinkAttributeSuspenseQueryHookResult = ReturnType<typeof useExplorerLinkAttributeSuspenseQuery>;
 export type ExplorerLinkAttributeQueryResult = Apollo.QueryResult<ExplorerLinkAttributeQuery, ExplorerLinkAttributeQueryVariables>;
 export declare const ExplorerLibraryDataDocument: Apollo.DocumentNode;
 /**
@@ -7958,8 +9513,17 @@ export declare function useExplorerLibraryDataLazyQuery(baseOptions?: Apollo.Laz
     multipleSort?: InputMaybe<Array<RecordSortInput> | RecordSortInput>;
     searchQuery?: InputMaybe<Scalars["String"]>;
 }>>;
+export declare function useExplorerLibraryDataSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerLibraryDataQuery, ExplorerLibraryDataQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerLibraryDataQuery, Exact<{
+    libraryId: Scalars["ID"];
+    attributeIds: Array<Scalars["ID"]> | Scalars["ID"];
+    pagination?: InputMaybe<RecordsPagination>;
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+    multipleSort?: InputMaybe<Array<RecordSortInput> | RecordSortInput>;
+    searchQuery?: InputMaybe<Scalars["String"]>;
+}>>;
 export type ExplorerLibraryDataQueryHookResult = ReturnType<typeof useExplorerLibraryDataQuery>;
 export type ExplorerLibraryDataLazyQueryHookResult = ReturnType<typeof useExplorerLibraryDataLazyQuery>;
+export type ExplorerLibraryDataSuspenseQueryHookResult = ReturnType<typeof useExplorerLibraryDataSuspenseQuery>;
 export type ExplorerLibraryDataQueryResult = Apollo.QueryResult<ExplorerLibraryDataQuery, ExplorerLibraryDataQueryVariables>;
 export declare const ExplorerLinkDataDocument: Apollo.DocumentNode;
 /**
@@ -7993,8 +9557,15 @@ export declare function useExplorerLinkDataLazyQuery(baseOptions?: Apollo.LazyQu
     parentRecordId?: InputMaybe<Scalars["String"]>;
     linkAttributeId: Scalars["ID"];
 }>>;
+export declare function useExplorerLinkDataSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerLinkDataQuery, ExplorerLinkDataQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerLinkDataQuery, Exact<{
+    attributeIds: Array<Scalars["ID"]> | Scalars["ID"];
+    parentLibraryId: Scalars["ID"];
+    parentRecordId?: InputMaybe<Scalars["String"]>;
+    linkAttributeId: Scalars["ID"];
+}>>;
 export type ExplorerLinkDataQueryHookResult = ReturnType<typeof useExplorerLinkDataQuery>;
 export type ExplorerLinkDataLazyQueryHookResult = ReturnType<typeof useExplorerLinkDataLazyQuery>;
+export type ExplorerLinkDataSuspenseQueryHookResult = ReturnType<typeof useExplorerLinkDataSuspenseQuery>;
 export type ExplorerLinkDataQueryResult = Apollo.QueryResult<ExplorerLinkDataQuery, ExplorerLinkDataQueryVariables>;
 export declare const GetLibraryAttributesDocument: Apollo.DocumentNode;
 /**
@@ -8019,8 +9590,12 @@ export declare function useGetLibraryAttributesQuery(baseOptions: Apollo.QueryHo
 export declare function useGetLibraryAttributesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLibraryAttributesQuery, GetLibraryAttributesQueryVariables>): Apollo.LazyQueryResultTuple<GetLibraryAttributesQuery, Exact<{
     libraryId: Scalars["ID"];
 }>>;
+export declare function useGetLibraryAttributesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLibraryAttributesQuery, GetLibraryAttributesQueryVariables>): Apollo.UseSuspenseQueryResult<GetLibraryAttributesQuery, Exact<{
+    libraryId: Scalars["ID"];
+}>>;
 export type GetLibraryAttributesQueryHookResult = ReturnType<typeof useGetLibraryAttributesQuery>;
 export type GetLibraryAttributesLazyQueryHookResult = ReturnType<typeof useGetLibraryAttributesLazyQuery>;
+export type GetLibraryAttributesSuspenseQueryHookResult = ReturnType<typeof useGetLibraryAttributesSuspenseQuery>;
 export type GetLibraryAttributesQueryResult = Apollo.QueryResult<GetLibraryAttributesQuery, GetLibraryAttributesQueryVariables>;
 export declare const ExplorerLibraryDetailsDocument: Apollo.DocumentNode;
 /**
@@ -8045,8 +9620,12 @@ export declare function useExplorerLibraryDetailsQuery(baseOptions: Apollo.Query
 export declare function useExplorerLibraryDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExplorerLibraryDetailsQuery, ExplorerLibraryDetailsQueryVariables>): Apollo.LazyQueryResultTuple<ExplorerLibraryDetailsQuery, Exact<{
     libraryId: Scalars["ID"];
 }>>;
+export declare function useExplorerLibraryDetailsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerLibraryDetailsQuery, ExplorerLibraryDetailsQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerLibraryDetailsQuery, Exact<{
+    libraryId: Scalars["ID"];
+}>>;
 export type ExplorerLibraryDetailsQueryHookResult = ReturnType<typeof useExplorerLibraryDetailsQuery>;
 export type ExplorerLibraryDetailsLazyQueryHookResult = ReturnType<typeof useExplorerLibraryDetailsLazyQuery>;
+export type ExplorerLibraryDetailsSuspenseQueryHookResult = ReturnType<typeof useExplorerLibraryDetailsSuspenseQuery>;
 export type ExplorerLibraryDetailsQueryResult = Apollo.QueryResult<ExplorerLibraryDetailsQuery, ExplorerLibraryDetailsQueryVariables>;
 export declare const ExplorerSelectionIdsDocument: Apollo.DocumentNode;
 /**
@@ -8074,8 +9653,13 @@ export declare function useExplorerSelectionIdsLazyQuery(baseOptions?: Apollo.La
     libraryId: Scalars["ID"];
     filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
 }>>;
+export declare function useExplorerSelectionIdsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ExplorerSelectionIdsQuery, ExplorerSelectionIdsQueryVariables>): Apollo.UseSuspenseQueryResult<ExplorerSelectionIdsQuery, Exact<{
+    libraryId: Scalars["ID"];
+    filters?: InputMaybe<Array<InputMaybe<RecordFilterInput>> | InputMaybe<RecordFilterInput>>;
+}>>;
 export type ExplorerSelectionIdsQueryHookResult = ReturnType<typeof useExplorerSelectionIdsQuery>;
 export type ExplorerSelectionIdsLazyQueryHookResult = ReturnType<typeof useExplorerSelectionIdsLazyQuery>;
+export type ExplorerSelectionIdsSuspenseQueryHookResult = ReturnType<typeof useExplorerSelectionIdsSuspenseQuery>;
 export type ExplorerSelectionIdsQueryResult = Apollo.QueryResult<ExplorerSelectionIdsQuery, ExplorerSelectionIdsQueryVariables>;
 export declare const MeDocument: Apollo.DocumentNode;
 /**
@@ -8099,8 +9683,12 @@ export declare function useMeQuery(baseOptions?: Apollo.QueryHookOptions<MeQuery
 export declare function useMeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MeQuery, MeQueryVariables>): Apollo.LazyQueryResultTuple<MeQuery, Exact<{
     [key: string]: never;
 }>>;
+export declare function useMeSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<MeQuery, MeQueryVariables>): Apollo.UseSuspenseQueryResult<MeQuery, Exact<{
+    [key: string]: never;
+}>>;
 export type MeQueryHookResult = ReturnType<typeof useMeQuery>;
 export type MeLazyQueryHookResult = ReturnType<typeof useMeLazyQuery>;
+export type MeSuspenseQueryHookResult = ReturnType<typeof useMeSuspenseQuery>;
 export type MeQueryResult = Apollo.QueryResult<MeQuery, MeQueryVariables>;
 export declare const UpdateViewDocument: Apollo.DocumentNode;
 export type UpdateViewMutationFn = Apollo.MutationFunction<UpdateViewMutation, UpdateViewMutationVariables>;
@@ -8127,6 +9715,48 @@ export declare function useUpdateViewMutation(baseOptions?: Apollo.MutationHookO
 export type UpdateViewMutationHookResult = ReturnType<typeof useUpdateViewMutation>;
 export type UpdateViewMutationResult = Apollo.MutationResult<UpdateViewMutation>;
 export type UpdateViewMutationOptions = Apollo.BaseMutationOptions<UpdateViewMutation, UpdateViewMutationVariables>;
+export declare const GetRecordHistoryDocument: Apollo.DocumentNode;
+/**
+ * __useGetRecordHistoryQuery__
+ *
+ * To run a query within a React component, call `useGetRecordHistoryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRecordHistoryQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRecordHistoryQuery({
+ *   variables: {
+ *      record: // value for 'record'
+ *      attributeId: // value for 'attributeId'
+ *      actions: // value for 'actions'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetRecordHistoryQuery(baseOptions: Apollo.QueryHookOptions<GetRecordHistoryQuery, GetRecordHistoryQueryVariables>): Apollo.QueryResult<GetRecordHistoryQuery, Exact<{
+    record: LogTopicRecordFilterInput;
+    attributeId?: InputMaybe<Scalars["String"]>;
+    actions?: InputMaybe<Array<LogAction> | LogAction>;
+    pagination?: InputMaybe<Pagination>;
+}>>;
+export declare function useGetRecordHistoryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetRecordHistoryQuery, GetRecordHistoryQueryVariables>): Apollo.LazyQueryResultTuple<GetRecordHistoryQuery, Exact<{
+    record: LogTopicRecordFilterInput;
+    attributeId?: InputMaybe<Scalars["String"]>;
+    actions?: InputMaybe<Array<LogAction> | LogAction>;
+    pagination?: InputMaybe<Pagination>;
+}>>;
+export declare function useGetRecordHistorySuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetRecordHistoryQuery, GetRecordHistoryQueryVariables>): Apollo.UseSuspenseQueryResult<GetRecordHistoryQuery, Exact<{
+    record: LogTopicRecordFilterInput;
+    attributeId?: InputMaybe<Scalars["String"]>;
+    actions?: InputMaybe<Array<LogAction> | LogAction>;
+    pagination?: InputMaybe<Pagination>;
+}>>;
+export type GetRecordHistoryQueryHookResult = ReturnType<typeof useGetRecordHistoryQuery>;
+export type GetRecordHistoryLazyQueryHookResult = ReturnType<typeof useGetRecordHistoryLazyQuery>;
+export type GetRecordHistorySuspenseQueryHookResult = ReturnType<typeof useGetRecordHistorySuspenseQuery>;
+export type GetRecordHistoryQueryResult = Apollo.QueryResult<GetRecordHistoryQuery, GetRecordHistoryQueryVariables>;
 export declare const TreeDataQueryDocument: Apollo.DocumentNode;
 /**
  * __useTreeDataQueryQuery__
@@ -8150,6 +9780,10 @@ export declare function useTreeDataQueryQuery(baseOptions: Apollo.QueryHookOptio
 export declare function useTreeDataQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TreeDataQueryQuery, TreeDataQueryQueryVariables>): Apollo.LazyQueryResultTuple<TreeDataQueryQuery, Exact<{
     treeId: Scalars["ID"];
 }>>;
+export declare function useTreeDataQuerySuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<TreeDataQueryQuery, TreeDataQueryQueryVariables>): Apollo.UseSuspenseQueryResult<TreeDataQueryQuery, Exact<{
+    treeId: Scalars["ID"];
+}>>;
 export type TreeDataQueryQueryHookResult = ReturnType<typeof useTreeDataQueryQuery>;
 export type TreeDataQueryLazyQueryHookResult = ReturnType<typeof useTreeDataQueryLazyQuery>;
+export type TreeDataQuerySuspenseQueryHookResult = ReturnType<typeof useTreeDataQuerySuspenseQuery>;
 export type TreeDataQueryQueryResult = Apollo.QueryResult<TreeDataQueryQuery, TreeDataQueryQueryVariables>;