@leav/ui 0.0.1-alpha-1 → 0.0.1-alpha-3

package/dist/_gqlTypes/index.js

@@ -0,0 +1,2643 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export var ActionIoTypes;
+(function (ActionIoTypes) {
+    ActionIoTypes["boolean"] = "boolean";
+    ActionIoTypes["number"] = "number";
+    ActionIoTypes["object"] = "object";
+    ActionIoTypes["string"] = "string";
+})(ActionIoTypes || (ActionIoTypes = {}));
+export var ApiKeysSortableFields;
+(function (ApiKeysSortableFields) {
+    ApiKeysSortableFields["createdAt"] = "createdAt";
+    ApiKeysSortableFields["createdBy"] = "createdBy";
+    ApiKeysSortableFields["expiresAt"] = "expiresAt";
+    ApiKeysSortableFields["label"] = "label";
+    ApiKeysSortableFields["modifiedAt"] = "modifiedAt";
+    ApiKeysSortableFields["modifiedBy"] = "modifiedBy";
+})(ApiKeysSortableFields || (ApiKeysSortableFields = {}));
+export var ApplicationEventTypes;
+(function (ApplicationEventTypes) {
+    ApplicationEventTypes["DELETE"] = "DELETE";
+    ApplicationEventTypes["SAVE"] = "SAVE";
+})(ApplicationEventTypes || (ApplicationEventTypes = {}));
+export var ApplicationSortableFields;
+(function (ApplicationSortableFields) {
+    ApplicationSortableFields["endpoint"] = "endpoint";
+    ApplicationSortableFields["id"] = "id";
+    ApplicationSortableFields["module"] = "module";
+    ApplicationSortableFields["system"] = "system";
+    ApplicationSortableFields["type"] = "type";
+})(ApplicationSortableFields || (ApplicationSortableFields = {}));
+export var ApplicationType;
+(function (ApplicationType) {
+    ApplicationType["external"] = "external";
+    ApplicationType["internal"] = "internal";
+})(ApplicationType || (ApplicationType = {}));
+export var AttributeFormat;
+(function (AttributeFormat) {
+    AttributeFormat["boolean"] = "boolean";
+    AttributeFormat["color"] = "color";
+    AttributeFormat["date"] = "date";
+    AttributeFormat["date_range"] = "date_range";
+    AttributeFormat["encrypted"] = "encrypted";
+    AttributeFormat["extended"] = "extended";
+    AttributeFormat["numeric"] = "numeric";
+    AttributeFormat["rich_text"] = "rich_text";
+    AttributeFormat["text"] = "text";
+})(AttributeFormat || (AttributeFormat = {}));
+export var AttributeType;
+(function (AttributeType) {
+    AttributeType["advanced"] = "advanced";
+    AttributeType["advanced_link"] = "advanced_link";
+    AttributeType["simple"] = "simple";
+    AttributeType["simple_link"] = "simple_link";
+    AttributeType["tree"] = "tree";
+})(AttributeType || (AttributeType = {}));
+export var AttributesSortableFields;
+(function (AttributesSortableFields) {
+    AttributesSortableFields["format"] = "format";
+    AttributesSortableFields["id"] = "id";
+    AttributesSortableFields["linked_library"] = "linked_library";
+    AttributesSortableFields["linked_tree"] = "linked_tree";
+    AttributesSortableFields["multiple_values"] = "multiple_values";
+    AttributesSortableFields["type"] = "type";
+})(AttributesSortableFields || (AttributesSortableFields = {}));
+export var AvailableLanguage;
+(function (AvailableLanguage) {
+    AvailableLanguage["en"] = "en";
+    AvailableLanguage["fr"] = "fr";
+})(AvailableLanguage || (AvailableLanguage = {}));
+export var FileType;
+(function (FileType) {
+    FileType["audio"] = "audio";
+    FileType["document"] = "document";
+    FileType["image"] = "image";
+    FileType["other"] = "other";
+    FileType["video"] = "video";
+})(FileType || (FileType = {}));
+export var FormElementTypes;
+(function (FormElementTypes) {
+    FormElementTypes["field"] = "field";
+    FormElementTypes["layout"] = "layout";
+})(FormElementTypes || (FormElementTypes = {}));
+export var FormsSortableFields;
+(function (FormsSortableFields) {
+    FormsSortableFields["id"] = "id";
+    FormsSortableFields["library"] = "library";
+    FormsSortableFields["system"] = "system";
+})(FormsSortableFields || (FormsSortableFields = {}));
+export var IoTypes;
+(function (IoTypes) {
+    IoTypes["boolean"] = "boolean";
+    IoTypes["number"] = "number";
+    IoTypes["object"] = "object";
+    IoTypes["string"] = "string";
+})(IoTypes || (IoTypes = {}));
+export var ImportMode;
+(function (ImportMode) {
+    ImportMode["insert"] = "insert";
+    ImportMode["update"] = "update";
+    ImportMode["upsert"] = "upsert";
+})(ImportMode || (ImportMode = {}));
+export var ImportType;
+(function (ImportType) {
+    ImportType["IGNORE"] = "IGNORE";
+    ImportType["LINK"] = "LINK";
+    ImportType["STANDARD"] = "STANDARD";
+})(ImportType || (ImportType = {}));
+export var LibrariesSortableFields;
+(function (LibrariesSortableFields) {
+    LibrariesSortableFields["behavior"] = "behavior";
+    LibrariesSortableFields["id"] = "id";
+    LibrariesSortableFields["system"] = "system";
+})(LibrariesSortableFields || (LibrariesSortableFields = {}));
+export var LibraryBehavior;
+(function (LibraryBehavior) {
+    LibraryBehavior["directories"] = "directories";
+    LibraryBehavior["files"] = "files";
+    LibraryBehavior["standard"] = "standard";
+})(LibraryBehavior || (LibraryBehavior = {}));
+export var LogAction;
+(function (LogAction) {
+    LogAction["API_KEY_DELETE"] = "API_KEY_DELETE";
+    LogAction["API_KEY_SAVE"] = "API_KEY_SAVE";
+    LogAction["APP_DELETE"] = "APP_DELETE";
+    LogAction["APP_SAVE"] = "APP_SAVE";
+    LogAction["ATTRIBUTE_DELETE"] = "ATTRIBUTE_DELETE";
+    LogAction["ATTRIBUTE_SAVE"] = "ATTRIBUTE_SAVE";
+    LogAction["CONFIG_IMPORT_END"] = "CONFIG_IMPORT_END";
+    LogAction["CONFIG_IMPORT_START"] = "CONFIG_IMPORT_START";
+    LogAction["DATA_IMPORT_END"] = "DATA_IMPORT_END";
+    LogAction["DATA_IMPORT_START"] = "DATA_IMPORT_START";
+    LogAction["EXPORT_END"] = "EXPORT_END";
+    LogAction["EXPORT_START"] = "EXPORT_START";
+    LogAction["GLOBAL_SETTINGS_SAVE"] = "GLOBAL_SETTINGS_SAVE";
+    LogAction["LIBRARY_DELETE"] = "LIBRARY_DELETE";
+    LogAction["LIBRARY_PURGE"] = "LIBRARY_PURGE";
+    LogAction["LIBRARY_SAVE"] = "LIBRARY_SAVE";
+    LogAction["PERMISSION_SAVE"] = "PERMISSION_SAVE";
+    LogAction["RECORD_DELETE"] = "RECORD_DELETE";
+    LogAction["RECORD_SAVE"] = "RECORD_SAVE";
+    LogAction["TASKS_DELETE"] = "TASKS_DELETE";
+    LogAction["TREE_ADD_ELEMENT"] = "TREE_ADD_ELEMENT";
+    LogAction["TREE_DELETE"] = "TREE_DELETE";
+    LogAction["TREE_DELETE_ELEMENT"] = "TREE_DELETE_ELEMENT";
+    LogAction["TREE_MOVE_ELEMENT"] = "TREE_MOVE_ELEMENT";
+    LogAction["TREE_SAVE"] = "TREE_SAVE";
+    LogAction["VALUE_DELETE"] = "VALUE_DELETE";
+    LogAction["VALUE_SAVE"] = "VALUE_SAVE";
+    LogAction["VERSION_PROFILE_DELETE"] = "VERSION_PROFILE_DELETE";
+    LogAction["VERSION_PROFILE_SAVE"] = "VERSION_PROFILE_SAVE";
+})(LogAction || (LogAction = {}));
+export var LogSortableField;
+(function (LogSortableField) {
+    LogSortableField["action"] = "action";
+    LogSortableField["instanceId"] = "instanceId";
+    LogSortableField["queryId"] = "queryId";
+    LogSortableField["time"] = "time";
+    LogSortableField["trigger"] = "trigger";
+    LogSortableField["userId"] = "userId";
+})(LogSortableField || (LogSortableField = {}));
+export var PermissionTypes;
+(function (PermissionTypes) {
+    PermissionTypes["admin"] = "admin";
+    PermissionTypes["application"] = "application";
+    PermissionTypes["attribute"] = "attribute";
+    PermissionTypes["library"] = "library";
+    PermissionTypes["record"] = "record";
+    PermissionTypes["record_attribute"] = "record_attribute";
+    PermissionTypes["tree"] = "tree";
+    PermissionTypes["tree_library"] = "tree_library";
+    PermissionTypes["tree_node"] = "tree_node";
+})(PermissionTypes || (PermissionTypes = {}));
+export var PermissionsActions;
+(function (PermissionsActions) {
+    PermissionsActions["access_application"] = "access_application";
+    PermissionsActions["access_attribute"] = "access_attribute";
+    PermissionsActions["access_library"] = "access_library";
+    PermissionsActions["access_record"] = "access_record";
+    PermissionsActions["access_tree"] = "access_tree";
+    PermissionsActions["admin_access_api_keys"] = "admin_access_api_keys";
+    PermissionsActions["admin_access_applications"] = "admin_access_applications";
+    PermissionsActions["admin_access_attributes"] = "admin_access_attributes";
+    PermissionsActions["admin_access_libraries"] = "admin_access_libraries";
+    PermissionsActions["admin_access_permissions"] = "admin_access_permissions";
+    PermissionsActions["admin_access_tasks"] = "admin_access_tasks";
+    PermissionsActions["admin_access_trees"] = "admin_access_trees";
+    PermissionsActions["admin_access_version_profiles"] = "admin_access_version_profiles";
+    PermissionsActions["admin_application"] = "admin_application";
+    PermissionsActions["admin_cancel_task"] = "admin_cancel_task";
+    PermissionsActions["admin_create_api_key"] = "admin_create_api_key";
+    PermissionsActions["admin_create_application"] = "admin_create_application";
+    PermissionsActions["admin_create_attribute"] = "admin_create_attribute";
+    PermissionsActions["admin_create_library"] = "admin_create_library";
+    PermissionsActions["admin_create_tree"] = "admin_create_tree";
+    PermissionsActions["admin_create_version_profile"] = "admin_create_version_profile";
+    PermissionsActions["admin_delete_api_key"] = "admin_delete_api_key";
+    PermissionsActions["admin_delete_application"] = "admin_delete_application";
+    PermissionsActions["admin_delete_attribute"] = "admin_delete_attribute";
+    PermissionsActions["admin_delete_library"] = "admin_delete_library";
+    PermissionsActions["admin_delete_task"] = "admin_delete_task";
+    PermissionsActions["admin_delete_tree"] = "admin_delete_tree";
+    PermissionsActions["admin_delete_version_profile"] = "admin_delete_version_profile";
+    PermissionsActions["admin_edit_api_key"] = "admin_edit_api_key";
+    PermissionsActions["admin_edit_application"] = "admin_edit_application";
+    PermissionsActions["admin_edit_attribute"] = "admin_edit_attribute";
+    PermissionsActions["admin_edit_global_settings"] = "admin_edit_global_settings";
+    PermissionsActions["admin_edit_library"] = "admin_edit_library";
+    PermissionsActions["admin_edit_permission"] = "admin_edit_permission";
+    PermissionsActions["admin_edit_tree"] = "admin_edit_tree";
+    PermissionsActions["admin_edit_version_profile"] = "admin_edit_version_profile";
+    PermissionsActions["admin_library"] = "admin_library";
+    PermissionsActions["admin_manage_global_preferences"] = "admin_manage_global_preferences";
+    PermissionsActions["create_record"] = "create_record";
+    PermissionsActions["delete_record"] = "delete_record";
+    PermissionsActions["detach"] = "detach";
+    PermissionsActions["edit_children"] = "edit_children";
+    PermissionsActions["edit_record"] = "edit_record";
+    PermissionsActions["edit_value"] = "edit_value";
+})(PermissionsActions || (PermissionsActions = {}));
+export var PermissionsRelation;
+(function (PermissionsRelation) {
+    PermissionsRelation["and"] = "and";
+    PermissionsRelation["or"] = "or";
+})(PermissionsRelation || (PermissionsRelation = {}));
+export var RecordFilterCondition;
+(function (RecordFilterCondition) {
+    RecordFilterCondition["BEGIN_WITH"] = "BEGIN_WITH";
+    RecordFilterCondition["BETWEEN"] = "BETWEEN";
+    RecordFilterCondition["CLASSIFIED_IN"] = "CLASSIFIED_IN";
+    RecordFilterCondition["CONTAINS"] = "CONTAINS";
+    RecordFilterCondition["END_AFTER"] = "END_AFTER";
+    RecordFilterCondition["END_BEFORE"] = "END_BEFORE";
+    RecordFilterCondition["END_ON"] = "END_ON";
+    RecordFilterCondition["END_WITH"] = "END_WITH";
+    RecordFilterCondition["EQUAL"] = "EQUAL";
+    RecordFilterCondition["GREATER_THAN"] = "GREATER_THAN";
+    RecordFilterCondition["IS_EMPTY"] = "IS_EMPTY";
+    RecordFilterCondition["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
+    RecordFilterCondition["LAST_MONTH"] = "LAST_MONTH";
+    RecordFilterCondition["LESS_THAN"] = "LESS_THAN";
+    RecordFilterCondition["NEXT_MONTH"] = "NEXT_MONTH";
+    RecordFilterCondition["NOT_CLASSIFIED_IN"] = "NOT_CLASSIFIED_IN";
+    RecordFilterCondition["NOT_CONTAINS"] = "NOT_CONTAINS";
+    RecordFilterCondition["NOT_EQUAL"] = "NOT_EQUAL";
+    RecordFilterCondition["START_AFTER"] = "START_AFTER";
+    RecordFilterCondition["START_BEFORE"] = "START_BEFORE";
+    RecordFilterCondition["START_ON"] = "START_ON";
+    RecordFilterCondition["TODAY"] = "TODAY";
+    RecordFilterCondition["TOMORROW"] = "TOMORROW";
+    RecordFilterCondition["VALUES_COUNT_EQUAL"] = "VALUES_COUNT_EQUAL";
+    RecordFilterCondition["VALUES_COUNT_GREATER_THAN"] = "VALUES_COUNT_GREATER_THAN";
+    RecordFilterCondition["VALUES_COUNT_LOWER_THAN"] = "VALUES_COUNT_LOWER_THAN";
+    RecordFilterCondition["YESTERDAY"] = "YESTERDAY";
+})(RecordFilterCondition || (RecordFilterCondition = {}));
+export var RecordFilterOperator;
+(function (RecordFilterOperator) {
+    RecordFilterOperator["AND"] = "AND";
+    RecordFilterOperator["CLOSE_BRACKET"] = "CLOSE_BRACKET";
+    RecordFilterOperator["OPEN_BRACKET"] = "OPEN_BRACKET";
+    RecordFilterOperator["OR"] = "OR";
+})(RecordFilterOperator || (RecordFilterOperator = {}));
+export var SortOrder;
+(function (SortOrder) {
+    SortOrder["asc"] = "asc";
+    SortOrder["desc"] = "desc";
+})(SortOrder || (SortOrder = {}));
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["CANCELED"] = "CANCELED";
+    TaskStatus["CREATED"] = "CREATED";
+    TaskStatus["DONE"] = "DONE";
+    TaskStatus["FAILED"] = "FAILED";
+    TaskStatus["PENDING"] = "PENDING";
+    TaskStatus["PENDING_CANCEL"] = "PENDING_CANCEL";
+    TaskStatus["RUNNING"] = "RUNNING";
+})(TaskStatus || (TaskStatus = {}));
+export var TaskType;
+(function (TaskType) {
+    TaskType["EXPORT"] = "EXPORT";
+    TaskType["IMPORT_CONFIG"] = "IMPORT_CONFIG";
+    TaskType["IMPORT_DATA"] = "IMPORT_DATA";
+    TaskType["INDEXATION"] = "INDEXATION";
+})(TaskType || (TaskType = {}));
+export var TreeBehavior;
+(function (TreeBehavior) {
+    TreeBehavior["files"] = "files";
+    TreeBehavior["standard"] = "standard";
+})(TreeBehavior || (TreeBehavior = {}));
+export var TreeEventTypes;
+(function (TreeEventTypes) {
+    TreeEventTypes["add"] = "add";
+    TreeEventTypes["move"] = "move";
+    TreeEventTypes["remove"] = "remove";
+})(TreeEventTypes || (TreeEventTypes = {}));
+export var TreesSortableFields;
+(function (TreesSortableFields) {
+    TreesSortableFields["behavior"] = "behavior";
+    TreesSortableFields["id"] = "id";
+    TreesSortableFields["system"] = "system";
+})(TreesSortableFields || (TreesSortableFields = {}));
+export var UserCoreDataKeys;
+(function (UserCoreDataKeys) {
+    UserCoreDataKeys["applications_consultation"] = "applications_consultation";
+})(UserCoreDataKeys || (UserCoreDataKeys = {}));
+export var ValueVersionMode;
+(function (ValueVersionMode) {
+    ValueVersionMode["simple"] = "simple";
+    ValueVersionMode["smart"] = "smart";
+})(ValueVersionMode || (ValueVersionMode = {}));
+export var VersionProfilesSortableFields;
+(function (VersionProfilesSortableFields) {
+    VersionProfilesSortableFields["id"] = "id";
+})(VersionProfilesSortableFields || (VersionProfilesSortableFields = {}));
+export var ViewSizes;
+(function (ViewSizes) {
+    ViewSizes["BIG"] = "BIG";
+    ViewSizes["MEDIUM"] = "MEDIUM";
+    ViewSizes["SMALL"] = "SMALL";
+})(ViewSizes || (ViewSizes = {}));
+export var ViewTypes;
+(function (ViewTypes) {
+    ViewTypes["cards"] = "cards";
+    ViewTypes["list"] = "list";
+    ViewTypes["timeline"] = "timeline";
+})(ViewTypes || (ViewTypes = {}));
+export const RecordIdentityFragmentDoc = gql `
+    fragment RecordIdentity on Record {
+  id
+  whoAmI {
+    id
+    label
+    subLabel
+    color
+    library {
+      id
+      label
+    }
+    preview
+  }
+}
+    `;
+export const DetailsApplicationFragmentDoc = gql `
+    fragment DetailsApplication on Application {
+  id
+  label
+  type
+  description
+  endpoint
+  url
+  color
+  icon {
+    ...RecordIdentity
+  }
+  module
+  permissions {
+    access_application
+    admin_application
+  }
+  settings
+}
+    ${RecordIdentityFragmentDoc}`;
+export const AttributeDetailsFragmentDoc = gql `
+    fragment AttributeDetails on Attribute {
+  id
+  type
+  format
+  system
+  readonly
+  label
+  description
+  multiple_values
+  metadata_fields {
+    id
+    label
+    type
+    format
+  }
+  versions_conf {
+    versionable
+    mode
+    profile {
+      id
+      label
+      trees {
+        id
+        label
+      }
+    }
+  }
+  libraries {
+    id
+    label
+  }
+  ... on StandardAttribute {
+    unique
+  }
+  ... on LinkAttribute {
+    linked_library {
+      id
+      label
+    }
+    reverse_link
+  }
+  ... on TreeAttribute {
+    linked_tree {
+      id
+      label
+    }
+  }
+}
+    `;
+export const AttributesByLibAttributeFragmentDoc = gql `
+    fragment AttributesByLibAttribute on Attribute {
+  id
+  type
+  format
+  label
+  multiple_values
+  system
+  readonly
+  ... on LinkAttribute {
+    linked_library {
+      id
+    }
+  }
+  ... on TreeAttribute {
+    linked_tree {
+      id
+      label
+      libraries {
+        library {
+          id
+          label
+        }
+      }
+    }
+  }
+  ... on StandardAttribute {
+    embedded_fields {
+      id
+      format
+      label
+    }
+  }
+}
+    `;
+export const LibraryLightFragmentDoc = gql `
+    fragment LibraryLight on Library {
+  id
+  label
+  icon {
+    id
+    whoAmI {
+      id
+      library {
+        id
+      }
+      preview
+    }
+  }
+}
+    `;
+export const LibraryLinkAttributeDetailsFragmentDoc = gql `
+    fragment LibraryLinkAttributeDetails on LinkAttribute {
+  linked_library {
+    id
+    behavior
+  }
+}
+    `;
+export const LibraryAttributesFragmentDoc = gql `
+    fragment LibraryAttributes on Attribute {
+  id
+  label
+  system
+  type
+  format
+  ...LibraryLinkAttributeDetails
+}
+    ${LibraryLinkAttributeDetailsFragmentDoc}`;
+export const LibraryPreviewsSettingsFragmentDoc = gql `
+    fragment LibraryPreviewsSettings on LibraryPreviewsSettings {
+  label
+  description
+  system
+  versions {
+    background
+    density
+    sizes {
+      name
+      size
+    }
+  }
+}
+    `;
+export const LibraryDetailsFragmentDoc = gql `
+    fragment LibraryDetails on Library {
+  id
+  label
+  behavior
+  system
+  label
+  fullTextAttributes {
+    id
+    label
+  }
+  attributes {
+    ...LibraryAttributes
+  }
+  permissions_conf {
+    permissionTreeAttributes {
+      id
+      ... on TreeAttribute {
+        linked_tree {
+          id
+        }
+      }
+      label
+    }
+    relation
+  }
+  recordIdentityConf {
+    label
+    subLabel
+    color
+    preview
+    treeColorPreview
+  }
+  permissions {
+    admin_library
+    access_library
+    access_record
+    create_record
+    edit_record
+    delete_record
+  }
+  icon {
+    ...RecordIdentity
+  }
+  previewsSettings {
+    ...LibraryPreviewsSettings
+  }
+}
+    ${LibraryAttributesFragmentDoc}
+${RecordIdentityFragmentDoc}
+${LibraryPreviewsSettingsFragmentDoc}`;
+export const ValuesVersionDetailsFragmentDoc = gql `
+    fragment ValuesVersionDetails on ValueVersion {
+  treeId
+  treeNode {
+    id
+    record {
+      id
+      whoAmI {
+        id
+        label
+        library {
+          id
+        }
+      }
+    }
+  }
+}
+    `;
+export const ValueDetailsFragmentDoc = gql `
+    fragment ValueDetails on GenericValue {
+  id_value
+  modified_at
+  modified_by {
+    ...RecordIdentity
+  }
+  created_at
+  created_by {
+    ...RecordIdentity
+  }
+  version {
+    ...ValuesVersionDetails
+  }
+  attribute {
+    id
+    format
+    type
+    system
+  }
+  metadata {
+    name
+    value {
+      id_value
+      modified_at
+      modified_by {
+        ...RecordIdentity
+      }
+      created_at
+      created_by {
+        ...RecordIdentity
+      }
+      version {
+        ...ValuesVersionDetails
+      }
+      value
+      raw_value
+    }
+  }
+  ... on Value {
+    value
+    raw_value
+  }
+  ... on LinkValue {
+    linkValue: value {
+      ...RecordIdentity
+    }
+  }
+  ... on TreeValue {
+    treeValue: value {
+      id
+      record {
+        ...RecordIdentity
+      }
+      ancestors {
+        record {
+          ...RecordIdentity
+        }
+      }
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}
+${ValuesVersionDetailsFragmentDoc}`;
+export const StandardValuesListFragmentFragmentDoc = gql `
+    fragment StandardValuesListFragment on StandardValuesListConf {
+  ... on StandardStringValuesListConf {
+    enable
+    allowFreeEntry
+    values
+  }
+  ... on StandardDateRangeValuesListConf {
+    enable
+    allowFreeEntry
+    dateRangeValues: values {
+      from
+      to
+    }
+  }
+}
+    `;
+export const RecordFormAttributeFragmentDoc = gql `
+    fragment RecordFormAttribute on Attribute {
+  id
+  label
+  description
+  type
+  format
+  system
+  readonly
+  multiple_values
+  permissions(record: {id: $recordId, library: $libraryId}) {
+    access_attribute
+    edit_value
+  }
+  versions_conf {
+    versionable
+    profile {
+      id
+      trees {
+        id
+        label
+      }
+    }
+  }
+  metadata_fields {
+    id
+    label
+    description
+    type
+    format
+    system
+    readonly
+    multiple_values
+    permissions(record: {id: $recordId, library: $libraryId}) {
+      access_attribute
+      edit_value
+    }
+    values_list {
+      ...StandardValuesListFragment
+    }
+    metadata_fields {
+      id
+    }
+  }
+  ... on StandardAttribute {
+    values_list {
+      ...StandardValuesListFragment
+    }
+  }
+  ... on LinkAttribute {
+    linked_library {
+      id
+      label
+      behavior
+      permissions {
+        create_record
+      }
+    }
+    linkValuesList: values_list {
+      enable
+      allowFreeEntry
+      values {
+        ...RecordIdentity
+      }
+    }
+  }
+  ... on TreeAttribute {
+    linked_tree {
+      id
+      label
+    }
+    treeValuesList: values_list {
+      enable
+      allowFreeEntry
+      values {
+        id
+        record {
+          ...RecordIdentity
+        }
+        ancestors {
+          record {
+            ...RecordIdentity
+          }
+        }
+      }
+    }
+  }
+}
+    ${StandardValuesListFragmentFragmentDoc}
+${RecordIdentityFragmentDoc}`;
+export const RecordFormElementFragmentDoc = gql `
+    fragment RecordFormElement on FormElementWithValues {
+  id
+  containerId
+  uiElementType
+  type
+  valueError
+  values {
+    ...ValueDetails
+  }
+  attribute {
+    ...RecordFormAttribute
+  }
+  settings {
+    key
+    value
+  }
+}
+    ${ValueDetailsFragmentDoc}
+${RecordFormAttributeFragmentDoc}`;
+export const TreeLightFragmentDoc = gql `
+    fragment TreeLight on Tree {
+  id
+  label
+}
+    `;
+export const TreeDetailsFragmentDoc = gql `
+    fragment TreeDetails on Tree {
+  id
+  label
+  behavior
+  system
+  libraries {
+    library {
+      id
+      label
+    }
+    settings {
+      allowMultiplePositions
+      allowedAtRoot
+      allowedChildren
+    }
+  }
+}
+    `;
+export const TreeNodeChildFragmentDoc = gql `
+    fragment TreeNodeChild on TreeNodeLight {
+  id
+  order
+  childrenCount
+  record {
+    ...RecordIdentity
+    active: property(attribute: "active") {
+      ... on Value {
+        value
+      }
+    }
+  }
+  ancestors {
+    id
+    record {
+      id
+      library {
+        id
+        label
+      }
+      ...RecordIdentity
+    }
+  }
+  permissions {
+    access_tree
+    detach
+    edit_children
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+export const ViewDetailsFragmentDoc = gql `
+    fragment ViewDetails on View {
+  id
+  display {
+    size
+    type
+  }
+  shared
+  created_by {
+    id
+    whoAmI {
+      id
+      label
+      library {
+        id
+      }
+    }
+  }
+  label
+  description
+  color
+  filters {
+    field
+    value
+    tree {
+      id
+      label
+    }
+    condition
+    operator
+  }
+  sort {
+    field
+    order
+  }
+  valuesVersions {
+    treeId
+    treeNode {
+      id
+      record {
+        ...RecordIdentity
+      }
+    }
+  }
+  settings {
+    name
+    value
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+export const CheckApplicationExistenceDocument = gql `
+    query CHECK_APPLICATION_EXISTENCE($id: ID, $endpoint: String) {
+  applications(filters: {id: $id, endpoint: $endpoint}) {
+    totalCount
+  }
+}
+    `;
+/**
+ * __useCheckApplicationExistenceQuery__
+ *
+ * To run a query within a React component, call `useCheckApplicationExistenceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckApplicationExistenceQuery` 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 } = useCheckApplicationExistenceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *      endpoint: // value for 'endpoint'
+ *   },
+ * });
+ */
+export function useCheckApplicationExistenceQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CheckApplicationExistenceDocument, options);
+}
+export function useCheckApplicationExistenceLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CheckApplicationExistenceDocument, options);
+}
+export const GetApplicationByIdDocument = gql `
+    query GET_APPLICATION_BY_ID($id: ID!) {
+  applications(filters: {id: $id}) {
+    list {
+      ...DetailsApplication
+    }
+  }
+}
+    ${DetailsApplicationFragmentDoc}`;
+/**
+ * __useGetApplicationByIdQuery__
+ *
+ * To run a query within a React component, call `useGetApplicationByIdQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetApplicationByIdQuery` 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 } = useGetApplicationByIdQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetApplicationByIdQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetApplicationByIdDocument, options);
+}
+export function useGetApplicationByIdLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetApplicationByIdDocument, options);
+}
+export const GetApplicationModulesDocument = gql `
+    query GET_APPLICATION_MODULES {
+  applicationsModules {
+    id
+    description
+    version
+  }
+}
+    `;
+/**
+ * __useGetApplicationModulesQuery__
+ *
+ * To run a query within a React component, call `useGetApplicationModulesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetApplicationModulesQuery` 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 } = useGetApplicationModulesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetApplicationModulesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetApplicationModulesDocument, options);
+}
+export function useGetApplicationModulesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetApplicationModulesDocument, options);
+}
+export const SaveApplicationDocument = gql `
+    mutation SAVE_APPLICATION($application: ApplicationInput!) {
+  saveApplication(application: $application) {
+    ...DetailsApplication
+  }
+}
+    ${DetailsApplicationFragmentDoc}`;
+/**
+ * __useSaveApplicationMutation__
+ *
+ * To run a mutation, you first call `useSaveApplicationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveApplicationMutation` 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 [saveApplicationMutation, { data, loading, error }] = useSaveApplicationMutation({
+ *   variables: {
+ *      application: // value for 'application'
+ *   },
+ * });
+ */
+export function useSaveApplicationMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveApplicationDocument, options);
+}
+export const CheckAttributeExistenceDocument = gql `
+    query CHECK_ATTRIBUTE_EXISTENCE($id: ID!) {
+  attributes(filters: {id: $id}) {
+    totalCount
+  }
+}
+    `;
+/**
+ * __useCheckAttributeExistenceQuery__
+ *
+ * To run a query within a React component, call `useCheckAttributeExistenceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckAttributeExistenceQuery` 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 } = useCheckAttributeExistenceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useCheckAttributeExistenceQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CheckAttributeExistenceDocument, options);
+}
+export function useCheckAttributeExistenceLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CheckAttributeExistenceDocument, options);
+}
+export const DeleteAttributeDocument = gql `
+    mutation DELETE_ATTRIBUTE($id: ID) {
+  deleteAttribute(id: $id) {
+    id
+  }
+}
+    `;
+/**
+ * __useDeleteAttributeMutation__
+ *
+ * To run a mutation, you first call `useDeleteAttributeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteAttributeMutation` 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 [deleteAttributeMutation, { data, loading, error }] = useDeleteAttributeMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteAttributeMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeleteAttributeDocument, options);
+}
+export const GetAttributeByIdDocument = gql `
+    query GET_ATTRIBUTE_BY_ID($id: ID) {
+  attributes(filters: {id: $id}) {
+    list {
+      ...AttributeDetails
+    }
+  }
+}
+    ${AttributeDetailsFragmentDoc}`;
+/**
+ * __useGetAttributeByIdQuery__
+ *
+ * To run a query within a React component, call `useGetAttributeByIdQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAttributeByIdQuery` 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 } = useGetAttributeByIdQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetAttributeByIdQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetAttributeByIdDocument, options);
+}
+export function useGetAttributeByIdLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetAttributeByIdDocument, options);
+}
+export const GetAttributesByLibDocument = gql `
+    query GET_ATTRIBUTES_BY_LIB($library: String!) {
+  attributes(filters: {libraries: [$library]}) {
+    list {
+      ...AttributesByLibAttribute
+    }
+  }
+}
+    ${AttributesByLibAttributeFragmentDoc}`;
+/**
+ * __useGetAttributesByLibQuery__
+ *
+ * To run a query within a React component, call `useGetAttributesByLibQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAttributesByLibQuery` 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 } = useGetAttributesByLibQuery({
+ *   variables: {
+ *      library: // value for 'library'
+ *   },
+ * });
+ */
+export function useGetAttributesByLibQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetAttributesByLibDocument, options);
+}
+export function useGetAttributesByLibLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetAttributesByLibDocument, options);
+}
+export const GetAttributesDocument = gql `
+    query GET_ATTRIBUTES($pagination: Pagination, $sort: SortAttributes, $filters: AttributesFiltersInput) {
+  attributes(pagination: $pagination, sort: $sort, filters: $filters) {
+    totalCount
+    list {
+      id
+      label
+      type
+      format
+      system
+    }
+  }
+}
+    `;
+/**
+ * __useGetAttributesQuery__
+ *
+ * To run a query within a React component, call `useGetAttributesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAttributesQuery` 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 } = useGetAttributesQuery({
+ *   variables: {
+ *      pagination: // value for 'pagination'
+ *      sort: // value for 'sort'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useGetAttributesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetAttributesDocument, options);
+}
+export function useGetAttributesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetAttributesDocument, options);
+}
+export const GetVersionProfilesDocument = gql `
+    query GET_VERSION_PROFILES($filters: VersionProfilesFiltersInput, $sort: SortVersionProfilesInput) {
+  versionProfiles(filters: $filters, sort: $sort) {
+    list {
+      id
+      label
+    }
+  }
+}
+    `;
+/**
+ * __useGetVersionProfilesQuery__
+ *
+ * To run a query within a React component, call `useGetVersionProfilesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVersionProfilesQuery` 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 } = useGetVersionProfilesQuery({
+ *   variables: {
+ *      filters: // value for 'filters'
+ *      sort: // value for 'sort'
+ *   },
+ * });
+ */
+export function useGetVersionProfilesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetVersionProfilesDocument, options);
+}
+export function useGetVersionProfilesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetVersionProfilesDocument, options);
+}
+export const GetVersionableAttributesByLibraryDocument = gql `
+    query GET_VERSIONABLE_ATTRIBUTES_BY_LIBRARY($libraryId: String!) {
+  attributes(filters: {libraries: [$libraryId], versionable: true}) {
+    list {
+      id
+      versions_conf {
+        versionable
+        profile {
+          id
+          trees {
+            id
+            label
+          }
+        }
+      }
+    }
+  }
+}
+    `;
+/**
+ * __useGetVersionableAttributesByLibraryQuery__
+ *
+ * To run a query within a React component, call `useGetVersionableAttributesByLibraryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVersionableAttributesByLibraryQuery` 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 } = useGetVersionableAttributesByLibraryQuery({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *   },
+ * });
+ */
+export function useGetVersionableAttributesByLibraryQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetVersionableAttributesByLibraryDocument, options);
+}
+export function useGetVersionableAttributesByLibraryLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetVersionableAttributesByLibraryDocument, options);
+}
+export const SaveAttributeDocument = gql `
+    mutation SAVE_ATTRIBUTE($attribute: AttributeInput!) {
+  saveAttribute(attribute: $attribute) {
+    ...AttributeDetails
+  }
+}
+    ${AttributeDetailsFragmentDoc}`;
+/**
+ * __useSaveAttributeMutation__
+ *
+ * To run a mutation, you first call `useSaveAttributeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveAttributeMutation` 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 [saveAttributeMutation, { data, loading, error }] = useSaveAttributeMutation({
+ *   variables: {
+ *      attribute: // value for 'attribute'
+ *   },
+ * });
+ */
+export function useSaveAttributeMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveAttributeDocument, options);
+}
+export const ExportDocument = gql `
+    query EXPORT($library: ID!, $attributes: [ID!], $filters: [RecordFilterInput!]) {
+  export(library: $library, attributes: $attributes, filters: $filters)
+}
+    `;
+/**
+ * __useExportQuery__
+ *
+ * To run a query within a React component, call `useExportQuery` and pass it any options that fit your needs.
+ * When your component renders, `useExportQuery` 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 } = useExportQuery({
+ *   variables: {
+ *      library: // value for 'library'
+ *      attributes: // value for 'attributes'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useExportQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(ExportDocument, options);
+}
+export function useExportLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(ExportDocument, options);
+}
+export const CreateDirectoryDocument = gql `
+    mutation CREATE_DIRECTORY($library: String!, $nodeId: String!, $name: String!) {
+  createDirectory(library: $library, nodeId: $nodeId, name: $name) {
+    ...RecordIdentity
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useCreateDirectoryMutation__
+ *
+ * To run a mutation, you first call `useCreateDirectoryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateDirectoryMutation` 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 [createDirectoryMutation, { data, loading, error }] = useCreateDirectoryMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *      nodeId: // value for 'nodeId'
+ *      name: // value for 'name'
+ *   },
+ * });
+ */
+export function useCreateDirectoryMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(CreateDirectoryDocument, options);
+}
+export const ForcePreviewsGenerationDocument = gql `
+    mutation FORCE_PREVIEWS_GENERATION($libraryId: ID!, $filters: [RecordFilterInput!], $recordIds: [ID!], $failedOnly: Boolean, $previewVersionSizeNames: [String!]) {
+  forcePreviewsGeneration(
+    libraryId: $libraryId
+    filters: $filters
+    recordIds: $recordIds
+    failedOnly: $failedOnly
+    previewVersionSizeNames: $previewVersionSizeNames
+  )
+}
+    `;
+/**
+ * __useForcePreviewsGenerationMutation__
+ *
+ * To run a mutation, you first call `useForcePreviewsGenerationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useForcePreviewsGenerationMutation` 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 [forcePreviewsGenerationMutation, { data, loading, error }] = useForcePreviewsGenerationMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      filters: // value for 'filters'
+ *      recordIds: // value for 'recordIds'
+ *      failedOnly: // value for 'failedOnly'
+ *      previewVersionSizeNames: // value for 'previewVersionSizeNames'
+ *   },
+ * });
+ */
+export function useForcePreviewsGenerationMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(ForcePreviewsGenerationDocument, options);
+}
+export const GetDirectoryDataDocument = gql `
+    query GET_DIRECTORY_DATA($library: ID!, $directoryId: String!) {
+  records(
+    library: $library
+    filters: [{field: "id", value: $directoryId, condition: EQUAL}]
+  ) {
+    list {
+      ...RecordIdentity
+      created_at: property(attribute: "created_at") {
+        ... on Value {
+          value
+        }
+      }
+      created_by: property(attribute: "created_by") {
+        ... on LinkValue {
+          value {
+            ...RecordIdentity
+          }
+        }
+      }
+      modified_at: property(attribute: "modified_at") {
+        ... on Value {
+          value
+        }
+      }
+      modified_by: property(attribute: "modified_by") {
+        ... on LinkValue {
+          value {
+            ...RecordIdentity
+          }
+        }
+      }
+      file_name: property(attribute: "file_name") {
+        ... on Value {
+          value
+        }
+      }
+      file_path: property(attribute: "file_path") {
+        ... on Value {
+          value
+        }
+      }
+      library {
+        behavior
+      }
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useGetDirectoryDataQuery__
+ *
+ * To run a query within a React component, call `useGetDirectoryDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDirectoryDataQuery` 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 } = useGetDirectoryDataQuery({
+ *   variables: {
+ *      library: // value for 'library'
+ *      directoryId: // value for 'directoryId'
+ *   },
+ * });
+ */
+export function useGetDirectoryDataQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetDirectoryDataDocument, options);
+}
+export function useGetDirectoryDataLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetDirectoryDataDocument, options);
+}
+export const UploadUpdateDocument = gql `
+    subscription UPLOAD_UPDATE($filters: UploadFiltersInput) {
+  upload(filters: $filters) {
+    userId
+    progress {
+      length
+      transferred
+      speed
+      runtime
+      remaining
+      percentage
+      eta
+      delta
+    }
+    uid
+  }
+}
+    `;
+/**
+ * __useUploadUpdateSubscription__
+ *
+ * To run a query within a React component, call `useUploadUpdateSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useUploadUpdateSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useUploadUpdateSubscription({
+ *   variables: {
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useUploadUpdateSubscription(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useSubscription(UploadUpdateDocument, options);
+}
+export const UploadDocument = gql `
+    mutation UPLOAD($library: String!, $nodeId: String!, $files: [FileInput!]!) {
+  upload(library: $library, nodeId: $nodeId, files: $files) {
+    uid
+    record {
+      ...RecordIdentity
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useUploadMutation__
+ *
+ * To run a mutation, you first call `useUploadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUploadMutation` 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 [uploadMutation, { data, loading, error }] = useUploadMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *      nodeId: // value for 'nodeId'
+ *      files: // value for 'files'
+ *   },
+ * });
+ */
+export function useUploadMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(UploadDocument, options);
+}
+export const ImportExcelDocument = gql `
+    mutation IMPORT_EXCEL($file: Upload!, $sheets: [SheetInput], $startAt: Int) {
+  importExcel(file: $file, sheets: $sheets, startAt: $startAt)
+}
+    `;
+/**
+ * __useImportExcelMutation__
+ *
+ * To run a mutation, you first call `useImportExcelMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useImportExcelMutation` 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 [importExcelMutation, { data, loading, error }] = useImportExcelMutation({
+ *   variables: {
+ *      file: // value for 'file'
+ *      sheets: // value for 'sheets'
+ *      startAt: // value for 'startAt'
+ *   },
+ * });
+ */
+export function useImportExcelMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(ImportExcelDocument, options);
+}
+export const CheckLibraryExistenceDocument = gql `
+    query CHECK_LIBRARY_EXISTENCE($id: [ID!]) {
+  libraries(filters: {id: $id}) {
+    totalCount
+  }
+}
+    `;
+/**
+ * __useCheckLibraryExistenceQuery__
+ *
+ * To run a query within a React component, call `useCheckLibraryExistenceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckLibraryExistenceQuery` 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 } = useCheckLibraryExistenceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useCheckLibraryExistenceQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CheckLibraryExistenceDocument, options);
+}
+export function useCheckLibraryExistenceLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CheckLibraryExistenceDocument, options);
+}
+export const DeleteLibraryDocument = gql `
+    mutation DELETE_LIBRARY($id: ID) {
+  deleteLibrary(id: $id) {
+    id
+  }
+}
+    `;
+/**
+ * __useDeleteLibraryMutation__
+ *
+ * To run a mutation, you first call `useDeleteLibraryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteLibraryMutation` 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 [deleteLibraryMutation, { data, loading, error }] = useDeleteLibraryMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteLibraryMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeleteLibraryDocument, options);
+}
+export const GetLibrariesDocument = gql `
+    query GET_LIBRARIES {
+  libraries {
+    list {
+      ...LibraryLight
+    }
+  }
+}
+    ${LibraryLightFragmentDoc}`;
+/**
+ * __useGetLibrariesQuery__
+ *
+ * To run a query within a React component, call `useGetLibrariesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetLibrariesQuery` 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 } = useGetLibrariesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetLibrariesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetLibrariesDocument, options);
+}
+export function useGetLibrariesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetLibrariesDocument, options);
+}
+export const GetLibraryByIdDocument = gql `
+    query GET_LIBRARY_BY_ID($id: [ID!]) {
+  libraries(filters: {id: $id}) {
+    list {
+      ...LibraryDetails
+    }
+  }
+}
+    ${LibraryDetailsFragmentDoc}`;
+/**
+ * __useGetLibraryByIdQuery__
+ *
+ * To run a query within a React component, call `useGetLibraryByIdQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetLibraryByIdQuery` 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 } = useGetLibraryByIdQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetLibraryByIdQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetLibraryByIdDocument, options);
+}
+export function useGetLibraryByIdLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetLibraryByIdDocument, options);
+}
+export const GetLibraryPermissionsDocument = gql `
+    query GET_LIBRARY_PERMISSIONS($libraryId: [ID!]) {
+  libraries(filters: {id: $libraryId}) {
+    list {
+      permissions {
+        access_library
+        access_record
+        create_record
+        edit_record
+        delete_record
+      }
+    }
+  }
+}
+    `;
+/**
+ * __useGetLibraryPermissionsQuery__
+ *
+ * To run a query within a React component, call `useGetLibraryPermissionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetLibraryPermissionsQuery` 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 } = useGetLibraryPermissionsQuery({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *   },
+ * });
+ */
+export function useGetLibraryPermissionsQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetLibraryPermissionsDocument, options);
+}
+export function useGetLibraryPermissionsLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetLibraryPermissionsDocument, options);
+}
+export const GetLibraryPreviewsSettingsDocument = gql `
+    query GET_LIBRARY_PREVIEWS_SETTINGS($id: ID!) {
+  libraries(filters: {id: [$id]}) {
+    list {
+      id
+      label
+      behavior
+      previewsSettings {
+        description
+        label
+        system
+        versions {
+          background
+          density
+          sizes {
+            name
+            size
+          }
+        }
+      }
+    }
+  }
+}
+    `;
+/**
+ * __useGetLibraryPreviewsSettingsQuery__
+ *
+ * To run a query within a React component, call `useGetLibraryPreviewsSettingsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetLibraryPreviewsSettingsQuery` 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 } = useGetLibraryPreviewsSettingsQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetLibraryPreviewsSettingsQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetLibraryPreviewsSettingsDocument, options);
+}
+export function useGetLibraryPreviewsSettingsLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetLibraryPreviewsSettingsDocument, options);
+}
+export const SaveLibraryDocument = gql `
+    mutation saveLibrary($library: LibraryInput!) {
+  saveLibrary(library: $library) {
+    ...LibraryDetails
+  }
+}
+    ${LibraryDetailsFragmentDoc}`;
+/**
+ * __useSaveLibraryMutation__
+ *
+ * To run a mutation, you first call `useSaveLibraryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveLibraryMutation` 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 [saveLibraryMutation, { data, loading, error }] = useSaveLibraryMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *   },
+ * });
+ */
+export function useSaveLibraryMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveLibraryDocument, options);
+}
+export const IsAllowedDocument = gql `
+    query IS_ALLOWED($type: PermissionTypes!, $actions: [PermissionsActions!]!, $applyTo: ID, $target: PermissionTarget) {
+  isAllowed(type: $type, actions: $actions, applyTo: $applyTo, target: $target) {
+    name
+    allowed
+  }
+}
+    `;
+/**
+ * __useIsAllowedQuery__
+ *
+ * To run a query within a React component, call `useIsAllowedQuery` and pass it any options that fit your needs.
+ * When your component renders, `useIsAllowedQuery` 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 } = useIsAllowedQuery({
+ *   variables: {
+ *      type: // value for 'type'
+ *      actions: // value for 'actions'
+ *      applyTo: // value for 'applyTo'
+ *      target: // value for 'target'
+ *   },
+ * });
+ */
+export function useIsAllowedQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(IsAllowedDocument, options);
+}
+export function useIsAllowedLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(IsAllowedDocument, options);
+}
+export const CreateRecordDocument = gql `
+    mutation CREATE_RECORD($library: ID!, $data: CreateRecordDataInput) {
+  createRecord(library: $library, data: $data) {
+    record {
+      ...RecordIdentity
+    }
+    valuesErrors {
+      attributeId
+      id_value
+      input
+      message
+      type
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useCreateRecordMutation__
+ *
+ * To run a mutation, you first call `useCreateRecordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateRecordMutation` 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 [createRecordMutation, { data, loading, error }] = useCreateRecordMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *      data: // value for 'data'
+ *   },
+ * });
+ */
+export function useCreateRecordMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(CreateRecordDocument, options);
+}
+export const DeactivateRecordsDocument = gql `
+    mutation DEACTIVATE_RECORDS($libraryId: String!, $recordsIds: [String!], $filters: [RecordFilterInput!]) {
+  deactivateRecords(
+    recordsIds: $recordsIds
+    filters: $filters
+    libraryId: $libraryId
+  ) {
+    id
+    ...RecordIdentity
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useDeactivateRecordsMutation__
+ *
+ * To run a mutation, you first call `useDeactivateRecordsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeactivateRecordsMutation` 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 [deactivateRecordsMutation, { data, loading, error }] = useDeactivateRecordsMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      recordsIds: // value for 'recordsIds'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useDeactivateRecordsMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeactivateRecordsDocument, options);
+}
+export const DoesFileExistAsChildDocument = gql `
+    query DOES_FILE_EXIST_AS_CHILD($parentNode: ID, $treeId: ID!, $filename: String!) {
+  doesFileExistAsChild(
+    parentNode: $parentNode
+    treeId: $treeId
+    filename: $filename
+  )
+}
+    `;
+/**
+ * __useDoesFileExistAsChildQuery__
+ *
+ * To run a query within a React component, call `useDoesFileExistAsChildQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDoesFileExistAsChildQuery` 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 } = useDoesFileExistAsChildQuery({
+ *   variables: {
+ *      parentNode: // value for 'parentNode'
+ *      treeId: // value for 'treeId'
+ *      filename: // value for 'filename'
+ *   },
+ * });
+ */
+export function useDoesFileExistAsChildQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(DoesFileExistAsChildDocument, options);
+}
+export function useDoesFileExistAsChildLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(DoesFileExistAsChildDocument, options);
+}
+export const GetFileDataDocument = gql `
+    query GET_FILE_DATA($library: ID!, $fileId: String!, $previewsStatusAttribute: ID!) {
+  records(
+    library: $library
+    filters: [{field: "id", value: $fileId, condition: EQUAL}]
+  ) {
+    list {
+      ...RecordIdentity
+      created_at: property(attribute: "created_at") {
+        ... on Value {
+          value
+        }
+      }
+      created_by: property(attribute: "created_by") {
+        ... on LinkValue {
+          value {
+            ...RecordIdentity
+          }
+        }
+      }
+      modified_at: property(attribute: "modified_at") {
+        ... on Value {
+          value
+        }
+      }
+      modified_by: property(attribute: "modified_by") {
+        ... on LinkValue {
+          value {
+            ...RecordIdentity
+          }
+        }
+      }
+      file_name: property(attribute: "file_name") {
+        ... on Value {
+          value
+        }
+      }
+      file_path: property(attribute: "file_path") {
+        ... on Value {
+          value
+        }
+      }
+      previews_status: property(attribute: $previewsStatusAttribute) {
+        ... on Value {
+          value
+        }
+      }
+      library {
+        behavior
+      }
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}`;
+/**
+ * __useGetFileDataQuery__
+ *
+ * To run a query within a React component, call `useGetFileDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFileDataQuery` 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 } = useGetFileDataQuery({
+ *   variables: {
+ *      library: // value for 'library'
+ *      fileId: // value for 'fileId'
+ *      previewsStatusAttribute: // value for 'previewsStatusAttribute'
+ *   },
+ * });
+ */
+export function useGetFileDataQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetFileDataDocument, options);
+}
+export function useGetFileDataLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetFileDataDocument, options);
+}
+export const RecordFormDocument = gql `
+    query RECORD_FORM($libraryId: String!, $formId: String!, $recordId: String, $version: [ValueVersionInput!]) {
+  recordForm(
+    recordId: $recordId
+    libraryId: $libraryId
+    formId: $formId
+    version: $version
+  ) {
+    id
+    recordId
+    library {
+      id
+    }
+    dependencyAttributes {
+      id
+    }
+    elements {
+      ...RecordFormElement
+    }
+  }
+}
+    ${RecordFormElementFragmentDoc}`;
+/**
+ * __useRecordFormQuery__
+ *
+ * To run a query within a React component, call `useRecordFormQuery` and pass it any options that fit your needs.
+ * When your component renders, `useRecordFormQuery` 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 } = useRecordFormQuery({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      formId: // value for 'formId'
+ *      recordId: // value for 'recordId'
+ *      version: // value for 'version'
+ *   },
+ * });
+ */
+export function useRecordFormQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(RecordFormDocument, options);
+}
+export function useRecordFormLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(RecordFormDocument, options);
+}
+export const RecordUpdateDocument = gql `
+    subscription RECORD_UPDATE($filters: RecordUpdateFilterInput) {
+  recordUpdate(filters: $filters) {
+    record {
+      ...RecordIdentity
+      modified_by: property(attribute: "modified_by") {
+        ... on LinkValue {
+          value {
+            ...RecordIdentity
+          }
+        }
+      }
+    }
+    updatedValues {
+      attribute
+      value {
+        ...ValueDetails
+      }
+    }
+  }
+}
+    ${RecordIdentityFragmentDoc}
+${ValueDetailsFragmentDoc}`;
+/**
+ * __useRecordUpdateSubscription__
+ *
+ * To run a query within a React component, call `useRecordUpdateSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useRecordUpdateSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useRecordUpdateSubscription({
+ *   variables: {
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useRecordUpdateSubscription(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useSubscription(RecordUpdateDocument, options);
+}
+export const IndexRecordsDocument = gql `
+    mutation INDEX_RECORDS($libraryId: String!, $records: [String!]) {
+  indexRecords(libraryId: $libraryId, records: $records)
+}
+    `;
+/**
+ * __useIndexRecordsMutation__
+ *
+ * To run a mutation, you first call `useIndexRecordsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useIndexRecordsMutation` 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 [indexRecordsMutation, { data, loading, error }] = useIndexRecordsMutation({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *      records: // value for 'records'
+ *   },
+ * });
+ */
+export function useIndexRecordsMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(IndexRecordsDocument, options);
+}
+export const CancelTaskDocument = gql `
+    mutation CANCEL_TASK($taskId: ID!) {
+  cancelTask(taskId: $taskId)
+}
+    `;
+/**
+ * __useCancelTaskMutation__
+ *
+ * To run a mutation, you first call `useCancelTaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCancelTaskMutation` 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 [cancelTaskMutation, { data, loading, error }] = useCancelTaskMutation({
+ *   variables: {
+ *      taskId: // value for 'taskId'
+ *   },
+ * });
+ */
+export function useCancelTaskMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(CancelTaskDocument, options);
+}
+export const CheckTreeExistenceDocument = gql `
+    query CHECK_TREE_EXISTENCE($id: [ID!]) {
+  trees(filters: {id: $id}) {
+    totalCount
+  }
+}
+    `;
+/**
+ * __useCheckTreeExistenceQuery__
+ *
+ * To run a query within a React component, call `useCheckTreeExistenceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckTreeExistenceQuery` 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 } = useCheckTreeExistenceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useCheckTreeExistenceQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CheckTreeExistenceDocument, options);
+}
+export function useCheckTreeExistenceLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CheckTreeExistenceDocument, options);
+}
+export const DeleteTreeDocument = gql `
+    mutation DELETE_TREE($id: ID!) {
+  deleteTree(id: $id) {
+    id
+  }
+}
+    `;
+/**
+ * __useDeleteTreeMutation__
+ *
+ * To run a mutation, you first call `useDeleteTreeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteTreeMutation` 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 [deleteTreeMutation, { data, loading, error }] = useDeleteTreeMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteTreeMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeleteTreeDocument, options);
+}
+export const GetTreeByIdDocument = gql `
+    query GET_TREE_BY_ID($id: [ID!]) {
+  trees(filters: {id: $id}) {
+    list {
+      ...TreeDetails
+    }
+  }
+}
+    ${TreeDetailsFragmentDoc}`;
+/**
+ * __useGetTreeByIdQuery__
+ *
+ * To run a query within a React component, call `useGetTreeByIdQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTreeByIdQuery` 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 } = useGetTreeByIdQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetTreeByIdQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetTreeByIdDocument, options);
+}
+export function useGetTreeByIdLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetTreeByIdDocument, options);
+}
+export const GetTreeLibrariesDocument = gql `
+    query GET_TREE_LIBRARIES($treeId: [ID!], $library: String) {
+  trees(filters: {id: $treeId, library: $library}) {
+    totalCount
+    list {
+      id
+      behavior
+      system
+      libraries {
+        library {
+          id
+          label
+          behavior
+          system
+        }
+        settings {
+          allowMultiplePositions
+          allowedChildren
+          allowedAtRoot
+        }
+      }
+    }
+  }
+}
+    `;
+/**
+ * __useGetTreeLibrariesQuery__
+ *
+ * To run a query within a React component, call `useGetTreeLibrariesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTreeLibrariesQuery` 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 } = useGetTreeLibrariesQuery({
+ *   variables: {
+ *      treeId: // value for 'treeId'
+ *      library: // value for 'library'
+ *   },
+ * });
+ */
+export function useGetTreeLibrariesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetTreeLibrariesDocument, options);
+}
+export function useGetTreeLibrariesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetTreeLibrariesDocument, options);
+}
+export const GetTreesDocument = gql `
+    query GET_TREES {
+  trees {
+    list {
+      ...TreeLight
+    }
+  }
+}
+    ${TreeLightFragmentDoc}`;
+/**
+ * __useGetTreesQuery__
+ *
+ * To run a query within a React component, call `useGetTreesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTreesQuery` 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 } = useGetTreesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetTreesQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetTreesDocument, options);
+}
+export function useGetTreesLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetTreesDocument, options);
+}
+export const SaveTreeDocument = gql `
+    mutation SAVE_TREE($tree: TreeInput!) {
+  saveTree(tree: $tree) {
+    ...TreeDetails
+  }
+}
+    ${TreeDetailsFragmentDoc}`;
+/**
+ * __useSaveTreeMutation__
+ *
+ * To run a mutation, you first call `useSaveTreeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveTreeMutation` 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 [saveTreeMutation, { data, loading, error }] = useSaveTreeMutation({
+ *   variables: {
+ *      tree: // value for 'tree'
+ *   },
+ * });
+ */
+export function useSaveTreeMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveTreeDocument, options);
+}
+export const TreeNodeChildrenDocument = gql `
+    query TREE_NODE_CHILDREN($treeId: ID!, $node: ID, $pagination: Pagination) {
+  treeNodeChildren(treeId: $treeId, node: $node, pagination: $pagination) {
+    totalCount
+    list {
+      ...TreeNodeChild
+    }
+  }
+}
+    ${TreeNodeChildFragmentDoc}`;
+/**
+ * __useTreeNodeChildrenQuery__
+ *
+ * To run a query within a React component, call `useTreeNodeChildrenQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTreeNodeChildrenQuery` 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 } = useTreeNodeChildrenQuery({
+ *   variables: {
+ *      treeId: // value for 'treeId'
+ *      node: // value for 'node'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useTreeNodeChildrenQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(TreeNodeChildrenDocument, options);
+}
+export function useTreeNodeChildrenLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(TreeNodeChildrenDocument, options);
+}
+export const GetUserDataDocument = gql `
+    query GET_USER_DATA($keys: [String!]!, $global: Boolean) {
+  userData(keys: $keys, global: $global) {
+    global
+    data
+  }
+}
+    `;
+/**
+ * __useGetUserDataQuery__
+ *
+ * To run a query within a React component, call `useGetUserDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserDataQuery` 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 } = useGetUserDataQuery({
+ *   variables: {
+ *      keys: // value for 'keys'
+ *      global: // value for 'global'
+ *   },
+ * });
+ */
+export function useGetUserDataQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetUserDataDocument, options);
+}
+export function useGetUserDataLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetUserDataDocument, options);
+}
+export const SaveUserDataDocument = gql `
+    mutation SAVE_USER_DATA($key: String!, $value: Any, $global: Boolean!) {
+  saveUserData(key: $key, value: $value, global: $global) {
+    global
+    data
+  }
+}
+    `;
+/**
+ * __useSaveUserDataMutation__
+ *
+ * To run a mutation, you first call `useSaveUserDataMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveUserDataMutation` 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 [saveUserDataMutation, { data, loading, error }] = useSaveUserDataMutation({
+ *   variables: {
+ *      key: // value for 'key'
+ *      value: // value for 'value'
+ *      global: // value for 'global'
+ *   },
+ * });
+ */
+export function useSaveUserDataMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveUserDataDocument, options);
+}
+export const DeleteValueDocument = gql `
+    mutation DELETE_VALUE($library: ID!, $recordId: ID!, $attribute: ID!, $value: ValueInput) {
+  deleteValue(
+    library: $library
+    recordId: $recordId
+    attribute: $attribute
+    value: $value
+  ) {
+    ...ValueDetails
+  }
+}
+    ${ValueDetailsFragmentDoc}`;
+/**
+ * __useDeleteValueMutation__
+ *
+ * To run a mutation, you first call `useDeleteValueMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteValueMutation` 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 [deleteValueMutation, { data, loading, error }] = useDeleteValueMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *      recordId: // value for 'recordId'
+ *      attribute: // value for 'attribute'
+ *      value: // value for 'value'
+ *   },
+ * });
+ */
+export function useDeleteValueMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeleteValueDocument, options);
+}
+export const SaveValueBatchDocument = gql `
+    mutation SAVE_VALUE_BATCH($library: ID!, $recordId: ID!, $version: [ValueVersionInput!], $values: [ValueBatchInput!]!, $deleteEmpty: Boolean) {
+  saveValueBatch(
+    library: $library
+    recordId: $recordId
+    version: $version
+    values: $values
+    deleteEmpty: $deleteEmpty
+  ) {
+    values {
+      ...ValueDetails
+    }
+    errors {
+      type
+      attribute
+      input
+      message
+    }
+  }
+}
+    ${ValueDetailsFragmentDoc}`;
+/**
+ * __useSaveValueBatchMutation__
+ *
+ * To run a mutation, you first call `useSaveValueBatchMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveValueBatchMutation` 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 [saveValueBatchMutation, { data, loading, error }] = useSaveValueBatchMutation({
+ *   variables: {
+ *      library: // value for 'library'
+ *      recordId: // value for 'recordId'
+ *      version: // value for 'version'
+ *      values: // value for 'values'
+ *      deleteEmpty: // value for 'deleteEmpty'
+ *   },
+ * });
+ */
+export function useSaveValueBatchMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(SaveValueBatchDocument, options);
+}
+export const DeleteViewDocument = gql `
+    mutation DELETE_VIEW($viewId: String!) {
+  deleteView(viewId: $viewId) {
+    id
+    library
+  }
+}
+    `;
+/**
+ * __useDeleteViewMutation__
+ *
+ * To run a mutation, you first call `useDeleteViewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteViewMutation` 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 [deleteViewMutation, { data, loading, error }] = useDeleteViewMutation({
+ *   variables: {
+ *      viewId: // value for 'viewId'
+ *   },
+ * });
+ */
+export function useDeleteViewMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(DeleteViewDocument, options);
+}
+export const GetViewDocument = gql `
+    query GET_VIEW($viewId: String!) {
+  view(viewId: $viewId) {
+    ...ViewDetails
+  }
+}
+    ${ViewDetailsFragmentDoc}`;
+/**
+ * __useGetViewQuery__
+ *
+ * To run a query within a React component, call `useGetViewQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetViewQuery` 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 } = useGetViewQuery({
+ *   variables: {
+ *      viewId: // value for 'viewId'
+ *   },
+ * });
+ */
+export function useGetViewQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetViewDocument, options);
+}
+export function useGetViewLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetViewDocument, options);
+}
+export const GetViewsListDocument = gql `
+    query GET_VIEWS_LIST($libraryId: String!) {
+  views(library: $libraryId) {
+    totalCount
+    list {
+      ...ViewDetails
+    }
+  }
+}
+    ${ViewDetailsFragmentDoc}`;
+/**
+ * __useGetViewsListQuery__
+ *
+ * To run a query within a React component, call `useGetViewsListQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetViewsListQuery` 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 } = useGetViewsListQuery({
+ *   variables: {
+ *      libraryId: // value for 'libraryId'
+ *   },
+ * });
+ */
+export function useGetViewsListQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(GetViewsListDocument, options);
+}
+export function useGetViewsListLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(GetViewsListDocument, options);
+}
+export const AddViewDocument = gql `
+    mutation ADD_VIEW($view: ViewInput!) {
+  saveView(view: $view) {
+    ...ViewDetails
+  }
+}
+    ${ViewDetailsFragmentDoc}`;
+/**
+ * __useAddViewMutation__
+ *
+ * To run a mutation, you first call `useAddViewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddViewMutation` 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 [addViewMutation, { data, loading, error }] = useAddViewMutation({
+ *   variables: {
+ *      view: // value for 'view'
+ *   },
+ * });
+ */
+export function useAddViewMutation(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useMutation(AddViewDocument, options);
+}
+//# sourceMappingURL=index.js.map