@riverscapes/common 2.0.20 → 2.0.22

package/dist_esnext/gen/schema.types.d.ts

@@ -0,0 +1,2795 @@
+import { JSONObject } from '../types';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    BigInt: {
+        input: number;
+        output: number;
+    };
+    DateTime: {
+        input: string;
+        output: string;
+    };
+    EmailAddress: {
+        input: string;
+        output: string;
+    };
+    JSONObject: {
+        input: JSONObject;
+        output: JSONObject;
+    };
+    URL: {
+        input: string;
+        output: string;
+    };
+};
+export type Collection = DbObj & HasOwner & HasStar & HasTags & {
+    __typename?: 'Collection';
+    citation?: Maybe<Scalars['String']['output']>;
+    contact?: Maybe<User>;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    heroImage?: Maybe<HeroImage>;
+    id: Scalars['ID']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    ownedBy: Owner;
+    permissions: ObjectPermissions;
+    projects: PaginatedProjects;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+    visibility: ProjectGroupVisibilityEnum;
+};
+export type CollectionProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type CollectionInput = {
+    citation?: InputMaybe<Scalars['String']['input']>;
+    clearContact?: InputMaybe<Scalars['Boolean']['input']>;
+    clearHeroImage?: InputMaybe<Scalars['Boolean']['input']>;
+    contact?: InputMaybe<OwnerInput>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    heroImageToken?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    visibility?: InputMaybe<ProjectGroupVisibilityEnum>;
+};
+export type DbObj = {
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type DbObjNotifications = {
+    createdBy: User;
+    createdById: Scalars['ID']['output'];
+    createdByName: Scalars['String']['output'];
+    createdOn: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedById: Scalars['ID']['output'];
+    updatedByName: Scalars['String']['output'];
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type DbObjNotificationsInput = {
+    createdById: Scalars['ID']['input'];
+    createdByName: Scalars['String']['input'];
+    createdOn: Scalars['DateTime']['input'];
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    summary: Scalars['String']['input'];
+    updatedById: Scalars['ID']['input'];
+    updatedByName: Scalars['String']['input'];
+    updatedOn: Scalars['DateTime']['input'];
+};
+export type DbSimpleObj = {
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type Dataset = DbObj & {
+    __typename?: 'Dataset';
+    analysisId?: Maybe<Scalars['String']['output']>;
+    attachedDatasets: PaginatedDatasets;
+    citation?: Maybe<Scalars['String']['output']>;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    datasetContainer: DatasetContainerTypesEnum;
+    datasetType: DatasetTypeEnum;
+    datasetXMLId: Scalars['String']['output'];
+    description: Scalars['String']['output'];
+    files: Array<FileDownloadMeta>;
+    id: Scalars['ID']['output'];
+    layers?: Maybe<Array<Maybe<DatasetLayer>>>;
+    localPath: Scalars['String']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    origin?: Maybe<Dataset>;
+    project: Project;
+    realizationXMLId?: Maybe<Scalars['String']['output']>;
+    refProject?: Maybe<Project>;
+    rsXPath: Scalars['String']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type DatasetAttachedDatasetsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export declare const DatasetContainerTypesEnum: {
+    readonly CommonDatasets: "CommonDatasets";
+    readonly Configuration: "Configuration";
+    readonly Datasets: "Datasets";
+    readonly Inputs: "Inputs";
+    readonly Intermediates: "Intermediates";
+    readonly Logs: "Logs";
+    readonly Outputs: "Outputs";
+    readonly Products: "Products";
+};
+export type DatasetContainerTypesEnum = typeof DatasetContainerTypesEnum[keyof typeof DatasetContainerTypesEnum];
+export type DatasetInput = {
+    citation?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    extRef?: InputMaybe<Scalars['ID']['input']>;
+    layers?: InputMaybe<Array<DatasetLayerInput>>;
+    localPath: Scalars['String']['input'];
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name: Scalars['String']['input'];
+    rsXPath: Scalars['String']['input'];
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export type DatasetLayer = {
+    __typename?: 'DatasetLayer';
+    citation?: Maybe<Scalars['String']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    lyrName: Scalars['String']['output'];
+    meta?: Maybe<Array<MetaData>>;
+    name: Scalars['String']['output'];
+    summary?: Maybe<Scalars['String']['output']>;
+};
+export type DatasetLayerInput = {
+    citation?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    lyrName: Scalars['String']['input'];
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export type DatasetLayerUpdate = {
+    citation?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export declare const DatasetTypeEnum: {
+    readonly AuxInstrumentFile: "AuxInstrumentFile";
+    readonly Csv: "CSV";
+    readonly ConfigFile: "ConfigFile";
+    readonly Dem: "DEM";
+    readonly DataTable: "DataTable";
+    readonly Database: "Database";
+    readonly File: "File";
+    readonly Geopackage: "Geopackage";
+    readonly HtmlFile: "HTMLFile";
+    readonly HillShade: "HillShade";
+    readonly Image: "Image";
+    readonly InstrumentFile: "InstrumentFile";
+    readonly LogFile: "LogFile";
+    readonly MsAccessDb: "MSAccessDB";
+    readonly Pdf: "PDF";
+    readonly Raster: "Raster";
+    readonly SqLiteDb: "SQLiteDB";
+    readonly SurveyQualityDb: "SurveyQualityDB";
+    readonly Tin: "TIN";
+    readonly Vector: "Vector";
+    readonly Video: "Video";
+    readonly ZipFile: "ZipFile";
+};
+export type DatasetTypeEnum = typeof DatasetTypeEnum[keyof typeof DatasetTypeEnum];
+export type DatasetUpdate = {
+    citation?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    dsId?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export declare const EntitiesWithImagesEnum: {
+    readonly Collection: "COLLECTION";
+    readonly Organization: "ORGANIZATION";
+    readonly Project: "PROJECT";
+    readonly ProjectType: "PROJECT_TYPE";
+    readonly User: "USER";
+};
+export type EntitiesWithImagesEnum = typeof EntitiesWithImagesEnum[keyof typeof EntitiesWithImagesEnum];
+export declare const EntityDeleteActionsEnum: {
+    readonly Delete: "DELETE";
+    readonly DeleteComplete: "DELETE_COMPLETE";
+    readonly MakePublic: "MAKE_PUBLIC";
+    readonly RequestTransfer: "REQUEST_TRANSFER";
+};
+export type EntityDeleteActionsEnum = typeof EntityDeleteActionsEnum[keyof typeof EntityDeleteActionsEnum];
+export type EntityDeletionOptions = {
+    totalDelete?: InputMaybe<Scalars['Boolean']['input']>;
+    transfer?: InputMaybe<TransferEntityItemsInput>;
+};
+export type FileDownloadMeta = FileDownloadMetaInterface & {
+    __typename?: 'FileDownloadMeta';
+    contentType?: Maybe<Scalars['String']['output']>;
+    downloadUrl?: Maybe<Scalars['String']['output']>;
+    etag?: Maybe<Scalars['String']['output']>;
+    localPath?: Maybe<Scalars['String']['output']>;
+    size?: Maybe<Scalars['BigInt']['output']>;
+};
+export type FileDownloadMetaInput = {
+    contentType?: InputMaybe<Scalars['String']['input']>;
+    localPath: Scalars['String']['input'];
+    md5: Scalars['String']['input'];
+    size?: InputMaybe<Scalars['BigInt']['input']>;
+};
+export type FileDownloadMetaInterface = {
+    contentType?: Maybe<Scalars['String']['output']>;
+    etag?: Maybe<Scalars['String']['output']>;
+    localPath?: Maybe<Scalars['String']['output']>;
+    size?: Maybe<Scalars['BigInt']['output']>;
+};
+export type FileUploadMeta = {
+    __typename?: 'FileUploadMeta';
+    downloadUrl: Scalars['String']['output'];
+    key: Scalars['String']['output'];
+};
+export type HasOwner = {
+    ownedBy: Owner;
+};
+export type HasStar = {
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+};
+export type HasTags = {
+    tags: Array<Scalars['String']['output']>;
+};
+export type HeroImage = {
+    __typename?: 'HeroImage';
+    lg?: Maybe<Scalars['URL']['output']>;
+    md?: Maybe<Scalars['URL']['output']>;
+    sm?: Maybe<Scalars['URL']['output']>;
+};
+export declare const ImageTypeEnum: {
+    readonly Avatar: "AVATAR";
+    readonly Hero: "HERO";
+    readonly Logo: "LOGO";
+};
+export type ImageTypeEnum = typeof ImageTypeEnum[keyof typeof ImageTypeEnum];
+export declare const JobStatusEnum: {
+    readonly Failed: "FAILED";
+    readonly Processing: "PROCESSING";
+    readonly Ready: "READY";
+    readonly Success: "SUCCESS";
+    readonly Unknown: "UNKNOWN";
+};
+export type JobStatusEnum = typeof JobStatusEnum[keyof typeof JobStatusEnum];
+export type JobStatusObj = {
+    __typename?: 'JobStatusObj';
+    data?: Maybe<Scalars['JSONObject']['output']>;
+    errors?: Maybe<Array<Scalars['String']['output']>>;
+    metaData?: Maybe<Scalars['JSONObject']['output']>;
+    percentComplete?: Maybe<Scalars['Int']['output']>;
+    projectId?: Maybe<Scalars['String']['output']>;
+    status: JobStatusEnum;
+};
+export type Link = {
+    __typename?: 'Link';
+    alt?: Maybe<Scalars['String']['output']>;
+    href: Scalars['URL']['output'];
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type LinkInput = {
+    alt?: InputMaybe<Scalars['String']['input']>;
+    href: Scalars['URL']['input'];
+    text?: InputMaybe<Scalars['String']['input']>;
+};
+export type MapCluster = {
+    __typename?: 'MapCluster';
+    coords: Array<Scalars['Float']['output']>;
+    count: Scalars['Int']['output'];
+    hash: Scalars['String']['output'];
+};
+export type MetaData = {
+    __typename?: 'MetaData';
+    ext?: Maybe<MetaDataExtEnum>;
+    key: Scalars['String']['output'];
+    locked?: Maybe<Scalars['Boolean']['output']>;
+    type?: Maybe<MetaDataTypeEnum>;
+    value: Scalars['String']['output'];
+};
+export declare const MetaDataExtEnum: {
+    readonly Dataset: "DATASET";
+    readonly Project: "PROJECT";
+    readonly Warehouse: "WAREHOUSE";
+};
+export type MetaDataExtEnum = typeof MetaDataExtEnum[keyof typeof MetaDataExtEnum];
+export type MetaDataInput = {
+    ext?: InputMaybe<MetaDataExtEnum>;
+    key: Scalars['String']['input'];
+    locked?: InputMaybe<Scalars['Boolean']['input']>;
+    type?: InputMaybe<MetaDataTypeEnum>;
+    value: Scalars['String']['input'];
+};
+export declare const MetaDataTypeEnum: {
+    readonly Boolean: "BOOLEAN";
+    readonly Filepath: "FILEPATH";
+    readonly Float: "FLOAT";
+    readonly Guid: "GUID";
+    readonly Hidden: "HIDDEN";
+    readonly Image: "IMAGE";
+    readonly Int: "INT";
+    readonly Isodate: "ISODATE";
+    readonly Json: "JSON";
+    readonly Markdown: "MARKDOWN";
+    readonly Richtext: "RICHTEXT";
+    readonly String: "STRING";
+    readonly Timestamp: "TIMESTAMP";
+    readonly Url: "URL";
+    readonly Video: "VIDEO";
+};
+export type MetaDataTypeEnum = typeof MetaDataTypeEnum[keyof typeof MetaDataTypeEnum];
+export type Mutation = {
+    __typename?: 'Mutation';
+    actionOrganizationInvite?: Maybe<OrganizationInvite>;
+    addCollectionProjects?: Maybe<Collection>;
+    adminReIndexOpenSearch?: Maybe<Scalars['String']['output']>;
+    adminRecreateOpenSearch?: Maybe<Scalars['Boolean']['output']>;
+    adminWipeDynamo?: Maybe<Scalars['Int']['output']>;
+    changeProjectOwner?: Maybe<Project>;
+    createCollection?: Maybe<Collection>;
+    createNotification?: Maybe<Notification>;
+    createOrganization?: Maybe<Organization>;
+    createOrganizationInvite?: Maybe<OrganizationInvite>;
+    createProfile?: Maybe<Profile>;
+    createProject?: Maybe<Project>;
+    createProjectType?: Maybe<ProjectType>;
+    createSavedSearch?: Maybe<SavedSearch>;
+    createTransfer?: Maybe<Transfer>;
+    deleteCollection?: Maybe<MutationResult>;
+    deleteNotifications?: Maybe<MutationResult>;
+    deleteOrganization?: Maybe<MutationResult>;
+    deleteOrganizationInvite?: Maybe<MutationResult>;
+    deleteProfile?: Maybe<MutationResult>;
+    deleteProject?: Maybe<MutationResult>;
+    deleteProjectType?: Maybe<MutationResult>;
+    deleteSavedSearch?: Maybe<MutationResult>;
+    deleteTransfer?: Maybe<MutationResult>;
+    finalizeProjectUpload?: Maybe<JobStatusObj>;
+    purgeProject?: Maybe<MutationResult>;
+    reIndexProjectXML?: Maybe<WatcherOutput>;
+    rebuildWebTiles: RebuildWebTilesResponse;
+    removeCollectionProjects?: Maybe<Collection>;
+    removeOrganizationMember?: Maybe<MutationResult>;
+    requestOrganizationInvite?: Maybe<OrganizationInvite>;
+    resendOrganizationInvite?: Maybe<OrganizationInvite>;
+    updateCollection?: Maybe<Collection>;
+    updateNotifications?: Maybe<MutationResult>;
+    updateOrganization?: Maybe<Organization>;
+    updateOrganizationMember?: Maybe<OrganizationUser>;
+    updateProfile?: Maybe<Profile>;
+    updateProject?: Maybe<Project>;
+    updateProjectDataset?: Maybe<Dataset>;
+    updateProjectDatasetLayer?: Maybe<DatasetLayer>;
+    updateProjectQAQC?: Maybe<QaqcEvent>;
+    updateProjectType?: Maybe<ProjectType>;
+    updateSavedSearch?: Maybe<SavedSearch>;
+    updateStar?: Maybe<MutationResult>;
+    updateTransfer?: Maybe<Transfer>;
+    zipRebuild?: Maybe<Project>;
+};
+export type MutationActionOrganizationInviteArgs = {
+    accept: Scalars['Boolean']['input'];
+    id: Scalars['ID']['input'];
+    role?: InputMaybe<OrganizationInviteRoleEnum>;
+};
+export type MutationAddCollectionProjectsArgs = {
+    collectionId: Scalars['ID']['input'];
+    projectIds: Array<Scalars['ID']['input']>;
+};
+export type MutationAdminReIndexOpenSearchArgs = {
+    paginationToken?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationChangeProjectOwnerArgs = {
+    owner: OwnerInput;
+    projectId: Scalars['ID']['input'];
+};
+export type MutationCreateCollectionArgs = {
+    collection: CollectionInput;
+    orgId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationCreateNotificationArgs = {
+    notification?: InputMaybe<NotificationInput>;
+};
+export type MutationCreateOrganizationArgs = {
+    organization: OrganizationInput;
+};
+export type MutationCreateOrganizationInviteArgs = {
+    email?: InputMaybe<Scalars['String']['input']>;
+    organizationId: Scalars['ID']['input'];
+    role?: InputMaybe<OrganizationInviteRoleEnum>;
+    userId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationCreateProfileArgs = {
+    id?: InputMaybe<Scalars['ID']['input']>;
+    profile: ProfileInput;
+};
+export type MutationCreateProjectArgs = {
+    agentId?: InputMaybe<Scalars['ID']['input']>;
+    orgId?: InputMaybe<Scalars['ID']['input']>;
+    project: ProjectInput;
+    projectId?: InputMaybe<Scalars['ID']['input']>;
+    projectTypeId?: InputMaybe<Scalars['String']['input']>;
+    userId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationCreateProjectTypeArgs = {
+    id: Scalars['String']['input'];
+    projectType: ProjectTypeInput;
+    state?: InputMaybe<ProjectTypeStateEnum>;
+};
+export type MutationCreateSavedSearchArgs = {
+    orgId?: InputMaybe<Scalars['ID']['input']>;
+    savedSearch: SavedSearchInput;
+};
+export type MutationCreateTransferArgs = {
+    transfer: TransferInput;
+};
+export type MutationDeleteCollectionArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteNotificationsArgs = {
+    all?: InputMaybe<Scalars['Boolean']['input']>;
+    ids?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type MutationDeleteOrganizationArgs = {
+    id: Scalars['ID']['input'];
+    options?: InputMaybe<EntityDeletionOptions>;
+};
+export type MutationDeleteOrganizationInviteArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteProfileArgs = {
+    options?: InputMaybe<EntityDeletionOptions>;
+};
+export type MutationDeleteProjectArgs = {
+    options?: InputMaybe<EntityDeletionOptions>;
+    projectId: Scalars['ID']['input'];
+};
+export type MutationDeleteProjectTypeArgs = {
+    id: Scalars['String']['input'];
+};
+export type MutationDeleteSavedSearchArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTransferArgs = {
+    transferId: Scalars['ID']['input'];
+};
+export type MutationFinalizeProjectUploadArgs = {
+    token: Scalars['String']['input'];
+};
+export type MutationPurgeProjectArgs = {
+    projectId: Scalars['ID']['input'];
+};
+export type MutationReIndexProjectXmlArgs = {
+    projectId: Scalars['ID']['input'];
+};
+export type MutationRebuildWebTilesArgs = {
+    force?: InputMaybe<Scalars['Boolean']['input']>;
+    projectId: Scalars['ID']['input'];
+    rsXPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type MutationRemoveCollectionProjectsArgs = {
+    collectionId: Scalars['ID']['input'];
+    projectIds: Array<Scalars['ID']['input']>;
+};
+export type MutationRemoveOrganizationMemberArgs = {
+    organizationId: Scalars['ID']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type MutationRequestOrganizationInviteArgs = {
+    organizationId: Scalars['ID']['input'];
+};
+export type MutationResendOrganizationInviteArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateCollectionArgs = {
+    collection?: InputMaybe<CollectionInput>;
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateNotificationsArgs = {
+    ids: Array<Scalars['ID']['input']>;
+    markAs: NotificationOperationEnum;
+};
+export type MutationUpdateOrganizationArgs = {
+    id: Scalars['ID']['input'];
+    organization: OrganizationInput;
+};
+export type MutationUpdateOrganizationMemberArgs = {
+    organizationId: Scalars['ID']['input'];
+    role?: InputMaybe<OrganizationRoleEnum>;
+    userId: Scalars['ID']['input'];
+};
+export type MutationUpdateProfileArgs = {
+    profile: ProfileInput;
+};
+export type MutationUpdateProjectArgs = {
+    agentId?: InputMaybe<Scalars['ID']['input']>;
+    project: ProjectInput;
+    projectId: Scalars['ID']['input'];
+    skipXMLUpdate?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type MutationUpdateProjectDatasetArgs = {
+    dataset: DatasetUpdate;
+    projectId: Scalars['ID']['input'];
+    rsXPath: Scalars['String']['input'];
+};
+export type MutationUpdateProjectDatasetLayerArgs = {
+    datasetLayer: DatasetLayerUpdate;
+    lyrName: Scalars['String']['input'];
+    projectId: Scalars['ID']['input'];
+    rsXPath: Scalars['String']['input'];
+};
+export type MutationUpdateProjectQaqcArgs = {
+    projectId: Scalars['ID']['input'];
+    qaqc: QaqcEventInput;
+    qaqcId: Scalars['ID']['input'];
+};
+export type MutationUpdateProjectTypeArgs = {
+    id: Scalars['String']['input'];
+    projectType: ProjectTypeInput;
+    state?: InputMaybe<ProjectTypeStateEnum>;
+};
+export type MutationUpdateSavedSearchArgs = {
+    id: Scalars['ID']['input'];
+    savedSearch: SavedSearchInput;
+};
+export type MutationUpdateStarArgs = {
+    id: Scalars['ID']['input'];
+    starred: Scalars['Boolean']['input'];
+    type: StarrableTypesEnum;
+};
+export type MutationUpdateTransferArgs = {
+    note?: InputMaybe<Scalars['String']['input']>;
+    state?: InputMaybe<TransferStateEnum>;
+    transferId: Scalars['ID']['input'];
+};
+export type MutationZipRebuildArgs = {
+    force?: InputMaybe<Scalars['Boolean']['input']>;
+    projectId: Scalars['ID']['input'];
+};
+export type MutationResult = {
+    __typename?: 'MutationResult';
+    error?: Maybe<Scalars['String']['output']>;
+    ids?: Maybe<Array<Scalars['ID']['output']>>;
+    message?: Maybe<Scalars['String']['output']>;
+    success: Scalars['Boolean']['output'];
+};
+export type MyStars = {
+    __typename?: 'MyStars';
+    collections: PaginatedCollections;
+    organizations: PaginatedOrganizations;
+    projects: PaginatedProjects;
+    savedSearches: PaginatedSavedSearches;
+    users: PaginatedUsers;
+};
+export type MyStarsCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type MyStarsOrganizationsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type MyStarsProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type MyStarsSavedSearchesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type MyStarsUsersArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type Notification = {
+    __typename?: 'Notification';
+    id: Scalars['ID']['output'];
+    object: DbObjNotifications;
+    seen: Scalars['Boolean']['output'];
+    subject: DbObjNotifications;
+    time: Scalars['DateTime']['output'];
+    type: NotificationTypesEnum;
+    verb: NotificationActionsEnum;
+};
+export declare const NotificationActionsEnum: {
+    readonly Created: "CREATED";
+    readonly Deleted: "DELETED";
+    readonly Renamed: "RENAMED";
+    readonly Transferred: "TRANSFERRED";
+    readonly Updated: "UPDATED";
+};
+export type NotificationActionsEnum = typeof NotificationActionsEnum[keyof typeof NotificationActionsEnum];
+export type NotificationInput = {
+    object: DbObjNotificationsInput;
+    subject: DbObjNotificationsInput;
+    type: NotificationTypesEnum;
+    verb: NotificationActionsEnum;
+};
+export declare const NotificationOperationEnum: {
+    readonly Delete: "DELETE";
+    readonly MarkRead: "MARK_READ";
+    readonly MarkUnread: "MARK_UNREAD";
+};
+export type NotificationOperationEnum = typeof NotificationOperationEnum[keyof typeof NotificationOperationEnum];
+export declare const NotificationTypesEnum: {
+    readonly Collection: "COLLECTION";
+    readonly Organization: "ORGANIZATION";
+    readonly Project: "PROJECT";
+    readonly SavedSearch: "SAVED_SEARCH";
+    readonly User: "USER";
+};
+export type NotificationTypesEnum = typeof NotificationTypesEnum[keyof typeof NotificationTypesEnum];
+export type ObjectPermissions = {
+    __typename?: 'ObjectPermissions';
+    delete?: Maybe<Scalars['Boolean']['output']>;
+    update?: Maybe<Scalars['Boolean']['output']>;
+    view?: Maybe<Scalars['Boolean']['output']>;
+};
+export type Organization = DbObj & HasStar & {
+    __typename?: 'Organization';
+    collections: PaginatedCollections;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    logo?: Maybe<Scalars['URL']['output']>;
+    meta: Array<MetaData>;
+    myRole: OrganizationRoleEnum;
+    name: Scalars['String']['output'];
+    organizationInvites: PaginatedOrganizationInvites;
+    organizationUsers: PaginatedOrganizationUsers;
+    permissions: ObjectPermissions;
+    preferences?: Maybe<Scalars['JSONObject']['output']>;
+    projects: PaginatedProjects;
+    savedSearches: PaginatedSavedSearches;
+    social?: Maybe<SocialLinks>;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type OrganizationCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type OrganizationOrganizationInvitesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type OrganizationOrganizationUsersArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    role?: InputMaybe<OrganizationRoleEnum>;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type OrganizationProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type OrganizationSavedSearchesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type OrganizationInput = {
+    clearLogo?: InputMaybe<Scalars['Boolean']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    logoToken?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    preferences?: InputMaybe<Scalars['JSONObject']['input']>;
+    social?: InputMaybe<SocialLinksInput>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export type OrganizationInvite = DbSimpleObj & {
+    __typename?: 'OrganizationInvite';
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    email?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    invitee?: Maybe<User>;
+    inviter: User;
+    organization: Organization;
+    retries: Scalars['Int']['output'];
+    role: OrganizationInviteRoleEnum;
+    state: OrganizationInviteStateEnum;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export declare const OrganizationInviteRoleEnum: {
+    readonly Admin: "ADMIN";
+    readonly Contributor: "CONTRIBUTOR";
+    readonly Viewer: "VIEWER";
+};
+export type OrganizationInviteRoleEnum = typeof OrganizationInviteRoleEnum[keyof typeof OrganizationInviteRoleEnum];
+export declare const OrganizationInviteStateEnum: {
+    readonly Accepted: "ACCEPTED";
+    readonly Expired: "EXPIRED";
+    readonly Invited: "INVITED";
+    readonly Rejected: "REJECTED";
+    readonly Requested: "REQUESTED";
+};
+export type OrganizationInviteStateEnum = typeof OrganizationInviteStateEnum[keyof typeof OrganizationInviteStateEnum];
+export declare const OrganizationRoleEnum: {
+    readonly Admin: "ADMIN";
+    readonly Contributor: "CONTRIBUTOR";
+    readonly None: "NONE";
+    readonly Owner: "OWNER";
+    readonly Viewer: "VIEWER";
+};
+export type OrganizationRoleEnum = typeof OrganizationRoleEnum[keyof typeof OrganizationRoleEnum];
+export type OrganizationUser = {
+    __typename?: 'OrganizationUser';
+    organization: Organization;
+    role: OrganizationRoleEnum;
+    user: User;
+};
+export type Owner = Organization | User;
+export type OwnerInput = {
+    id: Scalars['String']['input'];
+    type: OwnerInputTypesEnum;
+};
+export declare const OwnerInputTypesEnum: {
+    readonly Organization: "ORGANIZATION";
+    readonly User: "USER";
+};
+export type OwnerInputTypesEnum = typeof OwnerInputTypesEnum[keyof typeof OwnerInputTypesEnum];
+export type Owners = PaginatedUsers;
+export type PaginatedCollections = Pagination & {
+    __typename?: 'PaginatedCollections';
+    items: Array<Collection>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedDatasets = Pagination & {
+    __typename?: 'PaginatedDatasets';
+    items: Array<Dataset>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedFileDownloadMeta = Pagination & {
+    __typename?: 'PaginatedFileDownloadMeta';
+    items: Array<FileDownloadMeta>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedNotifications = Pagination & {
+    __typename?: 'PaginatedNotifications';
+    items: Array<Notification>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedOrganizationInvites = Pagination & {
+    __typename?: 'PaginatedOrganizationInvites';
+    items: Array<OrganizationInvite>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedOrganizationUsers = Pagination & {
+    __typename?: 'PaginatedOrganizationUsers';
+    items: Array<OrganizationUser>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedOrganizations = Pagination & {
+    __typename?: 'PaginatedOrganizations';
+    items: Array<Organization>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedProjectTypes = Pagination & {
+    __typename?: 'PaginatedProjectTypes';
+    items: Array<ProjectType>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedProjects = Pagination & {
+    __typename?: 'PaginatedProjects';
+    items: Array<Project>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedQaqcEvents = Pagination & {
+    __typename?: 'PaginatedQAQCEvents';
+    items: Array<QaqcEvent>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedSavedSearches = Pagination & {
+    __typename?: 'PaginatedSavedSearches';
+    items: Array<SavedSearch>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type PaginatedUsers = Pagination & {
+    __typename?: 'PaginatedUsers';
+    items: Array<User>;
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type Pagination = {
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type Profile = DbObj & UserInterface & {
+    __typename?: 'Profile';
+    affiliations: Array<Maybe<UserAffiliation>>;
+    avatar?: Maybe<Scalars['URL']['output']>;
+    collections: PaginatedCollections;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    initialized?: Maybe<Scalars['Boolean']['output']>;
+    isAdmin: Scalars['Boolean']['output'];
+    jobTitle?: Maybe<Scalars['String']['output']>;
+    lastLogin: Scalars['DateTime']['output'];
+    location?: Maybe<Scalars['String']['output']>;
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    notifications: PaginatedNotifications;
+    organizationInvites: PaginatedOrganizationInvites;
+    organizations: PaginatedOrganizations;
+    preferences: Scalars['JSONObject']['output'];
+    projects: PaginatedProjects;
+    savedSearches: PaginatedSavedSearches;
+    social: SocialLinks;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    stars: MyStars;
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type ProfileCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProfileNotificationsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    op?: InputMaybe<NotificationOperationEnum>;
+};
+export type ProfileOrganizationInvitesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProfileOrganizationsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProfileProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProfileSavedSearchesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProfileInput = {
+    affiliations?: InputMaybe<Array<UserAffiliationInput>>;
+    avatarToken?: InputMaybe<Scalars['String']['input']>;
+    clearAvatar?: InputMaybe<Scalars['Boolean']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    jobTitle?: InputMaybe<Scalars['String']['input']>;
+    location?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    preferences?: InputMaybe<Scalars['JSONObject']['input']>;
+    socialLinks?: InputMaybe<SocialLinksInput>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+};
+export type Project = DbObj & HasOwner & HasStar & {
+    __typename?: 'Project';
+    bounds?: Maybe<ProjectBounds>;
+    citation?: Maybe<Scalars['String']['output']>;
+    collections: PaginatedCollections;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    datasets: PaginatedDatasets;
+    deleted: Scalars['Boolean']['output'];
+    description: Scalars['String']['output'];
+    dirty: Scalars['Boolean']['output'];
+    files: Array<FileDownloadMeta>;
+    heroImage?: Maybe<HeroImage>;
+    id: Scalars['ID']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    ownedBy: Owner;
+    permissions: ObjectPermissions;
+    projectType: ProjectType;
+    qaqc: PaginatedQaqcEvents;
+    ref: Scalars['String']['output'];
+    sponsor?: Maybe<Owner>;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    totalSize?: Maybe<Scalars['BigInt']['output']>;
+    tree: ProjectTree;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+    visibility: ProjectVisibilityEnum;
+};
+export type ProjectCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProjectDatasetsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProjectQaqcArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type ProjectBounds = DbSimpleObj & {
+    __typename?: 'ProjectBounds';
+    area?: Maybe<Scalars['Float']['output']>;
+    bbox: Array<Scalars['Float']['output']>;
+    centroid: Array<Scalars['Float']['output']>;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    geoHash?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    polygonUrl: Scalars['URL']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export declare const ProjectDeleteChoicesEnum: {
+    readonly Delete: "DELETE";
+    readonly DeleteComplete: "DELETE_COMPLETE";
+};
+export type ProjectDeleteChoicesEnum = typeof ProjectDeleteChoicesEnum[keyof typeof ProjectDeleteChoicesEnum];
+export declare const ProjectGroupVisibilityEnum: {
+    readonly Public: "PUBLIC";
+    readonly Secret: "SECRET";
+};
+export type ProjectGroupVisibilityEnum = typeof ProjectGroupVisibilityEnum[keyof typeof ProjectGroupVisibilityEnum];
+export type ProjectInput = {
+    boundsToken?: InputMaybe<Scalars['String']['input']>;
+    citation?: InputMaybe<Scalars['String']['input']>;
+    clearBounds?: InputMaybe<Scalars['Boolean']['input']>;
+    clearHeroImage?: InputMaybe<Scalars['Boolean']['input']>;
+    clearSponsor?: InputMaybe<Scalars['Boolean']['input']>;
+    datasets?: InputMaybe<Array<DatasetInput>>;
+    deleteDatasets?: InputMaybe<Array<Scalars['ID']['input']>>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    heroImageToken?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    qaqc?: InputMaybe<Array<QaqcEventInput>>;
+    sponsor?: InputMaybe<OwnerInput>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    totalSize?: InputMaybe<Scalars['BigInt']['input']>;
+    visibility?: InputMaybe<ProjectVisibilityEnum>;
+};
+export type ProjectSearchMeta = {
+    __typename?: 'ProjectSearchMeta';
+    area?: Maybe<Scalars['Float']['output']>;
+    bbox?: Maybe<Array<Scalars['Float']['output']>>;
+    geoBuckets?: Maybe<Scalars['JSONObject']['output']>;
+    maxScore?: Maybe<Scalars['Float']['output']>;
+    metaDataBuckets: Scalars['JSONObject']['output'];
+    openSearch?: Maybe<Scalars['JSONObject']['output']>;
+    projectTypes?: Maybe<Scalars['JSONObject']['output']>;
+    searchTime?: Maybe<Scalars['Float']['output']>;
+};
+export type ProjectSearchParams = {
+    __typename?: 'ProjectSearchParams';
+    bbox?: Maybe<Array<Scalars['Float']['output']>>;
+    collection?: Maybe<Scalars['ID']['output']>;
+    createdOn?: Maybe<SearchDate>;
+    editableOnly?: Maybe<Scalars['Boolean']['output']>;
+    keywords?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Array<MetaData>>;
+    name?: Maybe<Scalars['String']['output']>;
+    ownedBy?: Maybe<SearchOwner>;
+    projectTypeId?: Maybe<Scalars['String']['output']>;
+    tags?: Maybe<Array<Scalars['String']['output']>>;
+    updatedOn?: Maybe<SearchDate>;
+};
+export type ProjectSearchParamsInput = {
+    bbox?: InputMaybe<Array<Scalars['Float']['input']>>;
+    boundsId?: InputMaybe<Scalars['ID']['input']>;
+    collection?: InputMaybe<Scalars['ID']['input']>;
+    createdOn?: InputMaybe<SearchDateInput>;
+    editableOnly?: InputMaybe<Scalars['Boolean']['input']>;
+    keywords?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    ownedBy?: InputMaybe<OwnerInput>;
+    projectTypeId?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    updatedOn?: InputMaybe<SearchDateInput>;
+};
+export type ProjectTree = {
+    __typename?: 'ProjectTree';
+    branches: Array<ProjectTreeBranch>;
+    defaultView?: Maybe<Scalars['ID']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    leaves: Array<ProjectTreeLeaf>;
+    name?: Maybe<Scalars['String']['output']>;
+    views: Array<ProjectTreeView>;
+};
+export type ProjectTreeBranch = {
+    __typename?: 'ProjectTreeBranch';
+    bid: Scalars['Int']['output'];
+    collapsed?: Maybe<Scalars['Boolean']['output']>;
+    label: Scalars['String']['output'];
+    pid: Scalars['Int']['output'];
+};
+export declare const ProjectTreeLayerTypeEnum: {
+    readonly File: "FILE";
+    readonly Line: "LINE";
+    readonly Point: "POINT";
+    readonly Polygon: "POLYGON";
+    readonly Raster: "RASTER";
+    readonly Report: "REPORT";
+    readonly Tin: "TIN";
+};
+export type ProjectTreeLayerTypeEnum = typeof ProjectTreeLayerTypeEnum[keyof typeof ProjectTreeLayerTypeEnum];
+export type ProjectTreeLeaf = {
+    __typename?: 'ProjectTreeLeaf';
+    blLayerId?: Maybe<Scalars['String']['output']>;
+    filePath?: Maybe<Scalars['String']['output']>;
+    id: Scalars['Int']['output'];
+    label: Scalars['String']['output'];
+    labelxpath?: Maybe<Scalars['String']['output']>;
+    layerType: ProjectTreeLayerTypeEnum;
+    lyrName?: Maybe<Scalars['String']['output']>;
+    nodeId?: Maybe<Scalars['ID']['output']>;
+    pid: Scalars['Int']['output'];
+    rsXPath: Scalars['String']['output'];
+    symbology?: Maybe<Scalars['String']['output']>;
+    transparency?: Maybe<Scalars['Int']['output']>;
+};
+export type ProjectTreeView = {
+    __typename?: 'ProjectTreeView';
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    layers: Array<ProjectTreeViewLayer>;
+    name: Scalars['String']['output'];
+};
+export type ProjectTreeViewLayer = {
+    __typename?: 'ProjectTreeViewLayer';
+    id: Scalars['ID']['output'];
+    visible?: Maybe<Scalars['Boolean']['output']>;
+};
+export type ProjectType = DbObj & {
+    __typename?: 'ProjectType';
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    logo?: Maybe<Scalars['URL']['output']>;
+    machineName: Scalars['String']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    state: ProjectTypeStateEnum;
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+    url?: Maybe<Scalars['URL']['output']>;
+};
+export type ProjectTypeInput = {
+    clearLogo?: InputMaybe<Scalars['Boolean']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    logoToken?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['URL']['input']>;
+};
+export declare const ProjectTypeStateEnum: {
+    readonly Active: "ACTIVE";
+    readonly Deleted: "DELETED";
+    readonly Suggested: "SUGGESTED";
+};
+export type ProjectTypeStateEnum = typeof ProjectTypeStateEnum[keyof typeof ProjectTypeStateEnum];
+export type ProjectUploadUrl = {
+    __typename?: 'ProjectUploadUrl';
+    fields?: Maybe<Scalars['JSONObject']['output']>;
+    origPath?: Maybe<Scalars['String']['output']>;
+    url: Scalars['String']['output'];
+};
+export type ProjectValidation = {
+    __typename?: 'ProjectValidation';
+    errors?: Maybe<Array<Maybe<ProjectValidationError>>>;
+    valid?: Maybe<Scalars['Boolean']['output']>;
+};
+export type ProjectValidationError = {
+    __typename?: 'ProjectValidationError';
+    code?: Maybe<Scalars['String']['output']>;
+    message: Scalars['String']['output'];
+    severity?: Maybe<SeverityEnum>;
+};
+export declare const ProjectVisibilityEnum: {
+    readonly Private: "PRIVATE";
+    readonly Public: "PUBLIC";
+    readonly Secret: "SECRET";
+};
+export type ProjectVisibilityEnum = typeof ProjectVisibilityEnum[keyof typeof ProjectVisibilityEnum];
+export type QaqcEvent = DbObj & {
+    __typename?: 'QAQCEvent';
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    datePerformed: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    performedBy: Scalars['String']['output'];
+    state: QaqcStateEnum;
+    summary: Scalars['String']['output'];
+    supportingLinks?: Maybe<Array<Link>>;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type QaqcEventInput = {
+    datePerformed: Scalars['DateTime']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    performedBy: Scalars['String']['input'];
+    state: QaqcStateEnum;
+    summary?: InputMaybe<Scalars['String']['input']>;
+    supportingLinks?: InputMaybe<Array<LinkInput>>;
+};
+export declare const QaqcStateEnum: {
+    readonly Failed: "FAILED";
+    readonly Passed: "PASSED";
+    readonly Provisional: "PROVISIONAL";
+};
+export type QaqcStateEnum = typeof QaqcStateEnum[keyof typeof QaqcStateEnum];
+export type Query = {
+    __typename?: 'Query';
+    checkUpload?: Maybe<JobStatusObj>;
+    collection?: Maybe<Collection>;
+    dirtyProjects?: Maybe<PaginatedProjects>;
+    downloadFile?: Maybe<FileDownloadMeta>;
+    downloadZip?: Maybe<ZipFileDownloadMeta>;
+    getLayerTiles?: Maybe<TileService>;
+    getWebSymbology?: Maybe<Symbology>;
+    info?: Maybe<WarehouseInfo>;
+    organization?: Maybe<Organization>;
+    profile?: Maybe<Profile>;
+    project?: Maybe<Project>;
+    projectType?: Maybe<ProjectType>;
+    projectTypes?: Maybe<PaginatedProjectTypes>;
+    requestUploadBounds?: Maybe<UploadUrl>;
+    requestUploadImage?: Maybe<UploadUrl>;
+    requestUploadProject?: Maybe<UploadProjectRequest>;
+    requestUploadProjectFilesUrl?: Maybe<Array<Maybe<UploadProjectFileUrls>>>;
+    savedSearch?: Maybe<SavedSearch>;
+    searchCollections: SearchCollectionPagination;
+    searchMapBounds: SearchMapBoundsResult;
+    searchMapClusters: SearchMapClusterResult;
+    searchOrganizations: SearchOrganizationPagination;
+    searchProjects: SearchProjectPagination;
+    searchSavedSearches: SearchSavedSearchPagination;
+    searchSuggest?: Maybe<SearchSuggestionResults>;
+    searchUsers: SearchUserPagination;
+    user?: Maybe<User>;
+    validateProject?: Maybe<ProjectValidation>;
+};
+export type QueryCheckUploadArgs = {
+    token: Scalars['String']['input'];
+};
+export type QueryCollectionArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryDirtyProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+};
+export type QueryDownloadFileArgs = {
+    filePath: Scalars['String']['input'];
+    projectId: Scalars['ID']['input'];
+};
+export type QueryDownloadZipArgs = {
+    projectId: Scalars['ID']['input'];
+};
+export type QueryGetLayerTilesArgs = {
+    projectId: Scalars['ID']['input'];
+    projectTypeId?: InputMaybe<Scalars['String']['input']>;
+    rsXPath: Scalars['String']['input'];
+};
+export type QueryGetWebSymbologyArgs = {
+    isRaster?: InputMaybe<Scalars['Boolean']['input']>;
+    name: Scalars['String']['input'];
+    projectTypeId?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryOrganizationArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProjectArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProjectTypeArgs = {
+    id: Scalars['String']['input'];
+};
+export type QueryProjectTypesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    state?: InputMaybe<ProjectTypeStateEnum>;
+};
+export type QueryRequestUploadImageArgs = {
+    entityId: Scalars['ID']['input'];
+    entityType: EntitiesWithImagesEnum;
+};
+export type QueryRequestUploadProjectArgs = {
+    etags: Array<Scalars['String']['input']>;
+    files: Array<Scalars['String']['input']>;
+    noDelete?: InputMaybe<Scalars['Boolean']['input']>;
+    owner?: InputMaybe<OwnerInput>;
+    projectId?: InputMaybe<Scalars['String']['input']>;
+    sizes: Array<Scalars['BigInt']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    visibility?: InputMaybe<ProjectVisibilityEnum>;
+};
+export type QueryRequestUploadProjectFilesUrlArgs = {
+    files: Array<Scalars['String']['input']>;
+    token: Scalars['String']['input'];
+};
+export type QuerySavedSearchArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QuerySearchCollectionsArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    offset: Scalars['Int']['input'];
+    params: SearchParamsInput;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type QuerySearchMapBoundsArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    params: ProjectSearchParamsInput;
+};
+export type QuerySearchMapClustersArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    params: ProjectSearchParamsInput;
+    precision: Scalars['Int']['input'];
+};
+export type QuerySearchOrganizationsArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    offset: Scalars['Int']['input'];
+    params: SearchParamsInput;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type QuerySearchProjectsArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    offset: Scalars['Int']['input'];
+    params: ProjectSearchParamsInput;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type QuerySearchSavedSearchesArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    offset: Scalars['Int']['input'];
+    params: SearchParamsInput;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type QuerySearchSuggestArgs = {
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    text: Scalars['String']['input'];
+    type?: InputMaybe<StarrableTypesEnum>;
+};
+export type QuerySearchUsersArgs = {
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+    limit: Scalars['Int']['input'];
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    offset: Scalars['Int']['input'];
+    params: SearchParamsInput;
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type QueryUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryValidateProjectArgs = {
+    files: Array<Scalars['String']['input']>;
+    owner?: InputMaybe<OwnerInput>;
+    xml: Scalars['String']['input'];
+};
+export declare const RampTypeEnum: {
+    readonly Discrete: "DISCRETE";
+    readonly Exact: "EXACT";
+    readonly Interpolated: "INTERPOLATED";
+};
+export type RampTypeEnum = typeof RampTypeEnum[keyof typeof RampTypeEnum];
+export type RebuildWebTilesResponse = {
+    __typename?: 'RebuildWebTilesResponse';
+    queued?: Maybe<Array<Scalars['String']['output']>>;
+    skipped?: Maybe<Array<Scalars['String']['output']>>;
+};
+export type SavedSearch = DbObj & HasOwner & HasStar & HasTags & {
+    __typename?: 'SavedSearch';
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    defaultSort?: Maybe<Array<SearchSortEnum>>;
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    ownedBy: Owner;
+    permissions: ObjectPermissions;
+    projects: SearchProjectPagination;
+    searchParams: ProjectSearchParams;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+    visibility: ProjectGroupVisibilityEnum;
+};
+export type SavedSearchProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type SavedSearchInput = {
+    defaultSort?: InputMaybe<Array<SearchSortEnum>>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    searchParams?: InputMaybe<ProjectSearchParamsInput>;
+    summary?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    visibility?: InputMaybe<ProjectGroupVisibilityEnum>;
+};
+export type SearchCollection = SearchResult & {
+    __typename?: 'SearchCollection';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: Collection;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchCollectionPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchCollectionPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchCollection>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchDataset = SearchResult & {
+    __typename?: 'SearchDataset';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: Dataset;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchDatasetPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchDatasetPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchDataset>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchDate = {
+    __typename?: 'SearchDate';
+    from?: Maybe<Scalars['DateTime']['output']>;
+    to?: Maybe<Scalars['DateTime']['output']>;
+};
+export type SearchDateInput = {
+    from?: InputMaybe<Scalars['DateTime']['input']>;
+    to?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type SearchMapBoundsItem = {
+    __typename?: 'SearchMapBoundsItem';
+    bounds: ProjectBounds;
+    clusters: Array<MapCluster>;
+    projectCount: Scalars['Int']['output'];
+};
+export type SearchMapBoundsResult = {
+    __typename?: 'SearchMapBoundsResult';
+    bounds: Array<SearchMapBoundsItem>;
+    remaining: Scalars['Int']['output'];
+};
+export type SearchMapClusterResult = {
+    __typename?: 'SearchMapClusterResult';
+    clusters: Array<MapCluster>;
+    remaining: Scalars['Int']['output'];
+};
+export type SearchMeta = {
+    __typename?: 'SearchMeta';
+    maxScore?: Maybe<Scalars['Float']['output']>;
+    metaDataBuckets: Scalars['JSONObject']['output'];
+    searchTime?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchMetaInterface = {
+    maxScore?: Maybe<Scalars['Float']['output']>;
+    metaDataBuckets: Scalars['JSONObject']['output'];
+    searchTime?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchNotification = SearchResult & {
+    __typename?: 'SearchNotification';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: Notification;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchNotificationPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchNotificationPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchNotification>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchOrganization = SearchResult & {
+    __typename?: 'SearchOrganization';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: Organization;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchOrganizationInvite = SearchResult & {
+    __typename?: 'SearchOrganizationInvite';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: OrganizationInvite;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchOrganizationInvitePagination = Pagination & SearchPagination & {
+    __typename?: 'SearchOrganizationInvitePagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchOrganizationInvite>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchOrganizationPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchOrganizationPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchOrganization>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchOwner = {
+    __typename?: 'SearchOwner';
+    id: Scalars['String']['output'];
+    type: OwnerInputTypesEnum;
+};
+export type SearchPagination = {
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchParamsInput = {
+    createdOn?: InputMaybe<SearchDateInput>;
+    editableOnly?: InputMaybe<Scalars['Boolean']['input']>;
+    keywords?: InputMaybe<Scalars['String']['input']>;
+    meta?: InputMaybe<Array<MetaDataInput>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    ownedBy?: InputMaybe<OwnerInput>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    updatedOn?: InputMaybe<SearchDateInput>;
+};
+export type SearchProject = SearchResult & {
+    __typename?: 'SearchProject';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: Project;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchProjectPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchProjectPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchProject>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchProjectType = SearchResult & {
+    __typename?: 'SearchProjectType';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: ProjectType;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchProjectTypePagination = Pagination & SearchPagination & {
+    __typename?: 'SearchProjectTypePagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchProjectType>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchQaqcEvent = SearchResult & {
+    __typename?: 'SearchQAQCEvent';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: QaqcEvent;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchQaqcEventPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchQAQCEventPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchQaqcEvent>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export type SearchResult = {
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchResultMeta = {
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    score: Scalars['Float']['output'];
+};
+export type SearchSavedSearch = SearchResult & {
+    __typename?: 'SearchSavedSearch';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: SavedSearch;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchSavedSearchPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchSavedSearchPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchSavedSearch>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export declare const SearchSortEnum: {
+    readonly AreaDesc: "AREA_DESC";
+    readonly DateCreatedAsc: "DATE_CREATED_ASC";
+    readonly DateCreatedDesc: "DATE_CREATED_DESC";
+    readonly DateUpdatedAsc: "DATE_UPDATED_ASC";
+    readonly DateUpdatedDesc: "DATE_UPDATED_DESC";
+    readonly Mine: "MINE";
+    readonly NameAsc: "NAME_ASC";
+    readonly NameDesc: "NAME_DESC";
+};
+export type SearchSortEnum = typeof SearchSortEnum[keyof typeof SearchSortEnum];
+export type SearchStats = ProjectSearchMeta | SearchMeta;
+export type SearchSuggestionResult = SearchResult & {
+    __typename?: 'SearchSuggestionResult';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item?: Maybe<DbObj>;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchSuggestionResults = {
+    __typename?: 'SearchSuggestionResults';
+    metaKey: Array<SearchSuggestions>;
+    metaValues: Array<SearchSuggestions>;
+    results: Array<SearchSuggestionResult>;
+    tags: Array<SearchSuggestions>;
+};
+export type SearchSuggestions = {
+    __typename?: 'SearchSuggestions';
+    freq?: Maybe<Scalars['Int']['output']>;
+    score: Scalars['Float']['output'];
+    text: Scalars['String']['output'];
+};
+export type SearchUser = SearchResult & {
+    __typename?: 'SearchUser';
+    highlights?: Maybe<Scalars['JSONObject']['output']>;
+    item: User;
+    score?: Maybe<Scalars['Float']['output']>;
+};
+export type SearchUserPagination = Pagination & SearchPagination & {
+    __typename?: 'SearchUserPagination';
+    limit: Scalars['Int']['output'];
+    offset: Scalars['Int']['output'];
+    results: Array<SearchUser>;
+    stats?: Maybe<SearchStats>;
+    total: Scalars['Int']['output'];
+};
+export declare const SearchableTypesEnum: {
+    readonly Collection: "COLLECTION";
+    readonly Organization: "ORGANIZATION";
+    readonly Project: "PROJECT";
+    readonly SavedSearch: "SAVED_SEARCH";
+    readonly User: "USER";
+};
+export type SearchableTypesEnum = typeof SearchableTypesEnum[keyof typeof SearchableTypesEnum];
+export declare const SeverityEnum: {
+    readonly Critical: "CRITICAL";
+    readonly Debug: "DEBUG";
+    readonly Error: "ERROR";
+    readonly Info: "INFO";
+    readonly Warning: "WARNING";
+};
+export type SeverityEnum = typeof SeverityEnum[keyof typeof SeverityEnum];
+export type SocialLinks = {
+    __typename?: 'SocialLinks';
+    facebook?: Maybe<Scalars['URL']['output']>;
+    instagram?: Maybe<Scalars['URL']['output']>;
+    linkedIn?: Maybe<Scalars['URL']['output']>;
+    tiktok?: Maybe<Scalars['URL']['output']>;
+    twitter?: Maybe<Scalars['URL']['output']>;
+    website?: Maybe<Scalars['URL']['output']>;
+};
+export type SocialLinksInput = {
+    facebook?: InputMaybe<Scalars['String']['input']>;
+    instagram?: InputMaybe<Scalars['String']['input']>;
+    linkedIn?: InputMaybe<Scalars['String']['input']>;
+    tiktok?: InputMaybe<Scalars['String']['input']>;
+    twitter?: InputMaybe<Scalars['String']['input']>;
+    website?: InputMaybe<Scalars['URL']['input']>;
+};
+export declare const StarrableTypesEnum: {
+    readonly Collection: "COLLECTION";
+    readonly Organization: "ORGANIZATION";
+    readonly Project: "PROJECT";
+    readonly SavedSearch: "SAVED_SEARCH";
+    readonly User: "USER";
+};
+export type StarrableTypesEnum = typeof StarrableTypesEnum[keyof typeof StarrableTypesEnum];
+export type Symbology = {
+    __typename?: 'Symbology';
+    error?: Maybe<Scalars['String']['output']>;
+    legend?: Maybe<Array<Array<Scalars['String']['output']>>>;
+    mapboxJson?: Maybe<Scalars['JSONObject']['output']>;
+    name: Scalars['String']['output'];
+    rampType?: Maybe<RampTypeEnum>;
+    state: SymbologyStateEnum;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export declare const SymbologyStateEnum: {
+    readonly Error: "ERROR";
+    readonly Fetching: "FETCHING";
+    readonly Found: "FOUND";
+    readonly Missing: "MISSING";
+    readonly NotApplicable: "NOT_APPLICABLE";
+    readonly Unknown: "UNKNOWN";
+};
+export type SymbologyStateEnum = typeof SymbologyStateEnum[keyof typeof SymbologyStateEnum];
+export type TileIndexOriginFile = FileDownloadMetaInterface & {
+    __typename?: 'TileIndexOriginFile';
+    contentType?: Maybe<Scalars['String']['output']>;
+    etag?: Maybe<Scalars['String']['output']>;
+    localPath?: Maybe<Scalars['String']['output']>;
+    size?: Maybe<Scalars['BigInt']['output']>;
+};
+export type TileService = {
+    __typename?: 'TileService';
+    bounds?: Maybe<Array<Maybe<Scalars['Float']['output']>>>;
+    duration?: Maybe<Scalars['Float']['output']>;
+    errorMsg?: Maybe<Scalars['String']['output']>;
+    format?: Maybe<Scalars['String']['output']>;
+    indexUrl?: Maybe<Scalars['String']['output']>;
+    lastState?: Maybe<Scalars['DateTime']['output']>;
+    layers?: Maybe<Array<Scalars['String']['output']>>;
+    localPath?: Maybe<Scalars['String']['output']>;
+    maxZoom?: Maybe<Scalars['Int']['output']>;
+    minZoom?: Maybe<Scalars['Int']['output']>;
+    numFiles?: Maybe<Scalars['Int']['output']>;
+    originFile?: Maybe<TileIndexOriginFile>;
+    projectId?: Maybe<Scalars['String']['output']>;
+    rasterStats?: Maybe<Scalars['JSONObject']['output']>;
+    rsXPath: Scalars['String']['output'];
+    started?: Maybe<Scalars['DateTime']['output']>;
+    state: TilingStateEnum;
+    symbologies?: Maybe<Array<Scalars['String']['output']>>;
+    tileType?: Maybe<TileTypesEnum>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export declare const TileTypesEnum: {
+    readonly Html: "HTML";
+    readonly Raster: "RASTER";
+    readonly VectorGpkg: "VECTOR_GPKG";
+    readonly VectorShp: "VECTOR_SHP";
+};
+export type TileTypesEnum = typeof TileTypesEnum[keyof typeof TileTypesEnum];
+export declare const TilingStateEnum: {
+    readonly Creating: "CREATING";
+    readonly Fetching: "FETCHING";
+    readonly FetchError: "FETCH_ERROR";
+    readonly IndexNotFound: "INDEX_NOT_FOUND";
+    readonly LayerNotFound: "LAYER_NOT_FOUND";
+    readonly NotApplicable: "NOT_APPLICABLE";
+    readonly NoGeometries: "NO_GEOMETRIES";
+    readonly Queued: "QUEUED";
+    readonly Success: "SUCCESS";
+    readonly TilingError: "TILING_ERROR";
+    readonly Timeout: "TIMEOUT";
+    readonly Unknown: "UNKNOWN";
+};
+export type TilingStateEnum = typeof TilingStateEnum[keyof typeof TilingStateEnum];
+export type Transfer = DbSimpleObj & {
+    __typename?: 'Transfer';
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    includeProjects?: Maybe<Scalars['Boolean']['output']>;
+    note: Scalars['String']['output'];
+    state: TransferStateEnum;
+    transferObjects: Array<TransferObject>;
+    transferTo: Owner;
+    transferType: TransferrableTypesEnum;
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type TransferEntityItemsInput = {
+    note: Scalars['String']['input'];
+    transferTo: OwnerInput;
+};
+export type TransferInput = {
+    includeProjects?: InputMaybe<Scalars['Boolean']['input']>;
+    note: Scalars['String']['input'];
+    objectIds: Array<Scalars['ID']['input']>;
+    transferTo: OwnerInput;
+    transferType: TransferrableTypesEnum;
+};
+export type TransferObject = Collection | Organization | Project | User;
+export declare const TransferStateEnum: {
+    readonly Accepted: "ACCEPTED";
+    readonly Expired: "EXPIRED";
+    readonly InProgress: "IN_PROGRESS";
+    readonly Proposed: "PROPOSED";
+    readonly Rejected: "REJECTED";
+};
+export type TransferStateEnum = typeof TransferStateEnum[keyof typeof TransferStateEnum];
+export declare const TransferrableTypesEnum: {
+    readonly Collection: "COLLECTION";
+    readonly Organization: "ORGANIZATION";
+    readonly Project: "PROJECT";
+    readonly User: "USER";
+};
+export type TransferrableTypesEnum = typeof TransferrableTypesEnum[keyof typeof TransferrableTypesEnum];
+export type UploadProjectFileUrls = {
+    __typename?: 'UploadProjectFileUrls';
+    relPath: Scalars['String']['output'];
+    urls?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type UploadProjectRequest = {
+    __typename?: 'UploadProjectRequest';
+    create: Array<Scalars['String']['output']>;
+    delete: Array<Scalars['String']['output']>;
+    newId?: Maybe<Scalars['String']['output']>;
+    token: Scalars['String']['output'];
+    update: Array<Scalars['String']['output']>;
+};
+export type UploadUrl = {
+    __typename?: 'UploadUrl';
+    fields: Scalars['JSONObject']['output'];
+    token: Scalars['String']['output'];
+    url: Scalars['String']['output'];
+};
+export type User = DbObj & UserInterface & {
+    __typename?: 'User';
+    affiliations: Array<Maybe<UserAffiliation>>;
+    avatar?: Maybe<Scalars['URL']['output']>;
+    collections: PaginatedCollections;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    jobTitle?: Maybe<Scalars['String']['output']>;
+    lastLogin: Scalars['DateTime']['output'];
+    location?: Maybe<Scalars['String']['output']>;
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    organizations: PaginatedOrganizations;
+    projects: PaginatedProjects;
+    savedSearches: PaginatedSavedSearches;
+    social: SocialLinks;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type UserCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserOrganizationsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserSavedSearchesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserAffiliation = {
+    __typename?: 'UserAffiliation';
+    affiliationRole?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    url?: Maybe<Scalars['URL']['output']>;
+};
+export type UserAffiliationInput = {
+    affiliationRole?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    url?: InputMaybe<Scalars['URL']['input']>;
+};
+export type UserInterface = {
+    affiliations: Array<Maybe<UserAffiliation>>;
+    avatar?: Maybe<Scalars['URL']['output']>;
+    collections: PaginatedCollections;
+    createdBy: User;
+    createdOn: Scalars['DateTime']['output'];
+    description: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    jobTitle?: Maybe<Scalars['String']['output']>;
+    lastLogin: Scalars['DateTime']['output'];
+    location?: Maybe<Scalars['String']['output']>;
+    meta: Array<MetaData>;
+    name: Scalars['String']['output'];
+    projects: PaginatedProjects;
+    savedSearches: PaginatedSavedSearches;
+    social: SocialLinks;
+    starred: Scalars['Boolean']['output'];
+    starredCount: Scalars['Int']['output'];
+    summary: Scalars['String']['output'];
+    updatedBy: User;
+    updatedOn: Scalars['DateTime']['output'];
+};
+export type UserInterfaceCollectionsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserInterfaceProjectsArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type UserInterfaceSavedSearchesArgs = {
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+};
+export type WarehouseInfo = {
+    __typename?: 'WarehouseInfo';
+    api?: Maybe<Scalars['String']['output']>;
+    businessLogic?: Maybe<Scalars['String']['output']>;
+    projectFile?: Maybe<Scalars['String']['output']>;
+    warehouse?: Maybe<Scalars['String']['output']>;
+    xml?: Maybe<Scalars['String']['output']>;
+    xsd?: Maybe<Scalars['String']['output']>;
+};
+export type WatcherOutput = {
+    __typename?: 'WatcherOutput';
+    errors?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    message?: Maybe<Scalars['String']['output']>;
+    results?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type ZipFileDownloadMeta = FileDownloadMetaInterface & {
+    __typename?: 'ZipFileDownloadMeta';
+    contentType?: Maybe<Scalars['String']['output']>;
+    downloadUrl?: Maybe<Scalars['String']['output']>;
+    etag?: Maybe<Scalars['String']['output']>;
+    localPath?: Maybe<Scalars['String']['output']>;
+    pendingSince?: Maybe<Scalars['DateTime']['output']>;
+    progress?: Maybe<Scalars['Int']['output']>;
+    size?: Maybe<Scalars['BigInt']['output']>;
+};
+export type AdminReIndexOpenSearchMutationVariables = Exact<{
+    paginationToken?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type AdminReIndexOpenSearchMutation = {
+    __typename?: 'Mutation';
+    adminReIndexOpenSearch?: string | null;
+};
+export type AdminRecreateOpenSearchMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AdminRecreateOpenSearchMutation = {
+    __typename?: 'Mutation';
+    adminRecreateOpenSearch?: boolean | null;
+};
+export type DeleteProjectMutationVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+    options?: InputMaybe<EntityDeletionOptions>;
+}>;
+export type DeleteProjectMutation = {
+    __typename?: 'Mutation';
+    deleteProject?: {
+        __typename?: 'MutationResult';
+        error?: string | null;
+        ids?: Array<string> | null;
+        message?: string | null;
+        success: boolean;
+    } | null;
+};
+export type DirtyProjectsQueryVariables = Exact<{
+    limit: Scalars['Int']['input'];
+    offset: Scalars['Int']['input'];
+}>;
+export type DirtyProjectsQuery = {
+    __typename?: 'Query';
+    dirtyProjects?: {
+        __typename?: 'PaginatedProjects';
+        limit: number;
+        offset: number;
+        total: number;
+        items: Array<{
+            __typename?: 'Project';
+            id: string;
+            name: string;
+            description: string;
+            citation?: string | null;
+            summary: string;
+            updatedOn: string;
+            createdOn: string;
+            deleted: boolean;
+            dirty: boolean;
+            ref: string;
+            bounds?: {
+                __typename?: 'ProjectBounds';
+                id: string;
+                polygonUrl: string;
+            } | null;
+            meta: Array<{
+                __typename?: 'MetaData';
+                ext?: MetaDataExtEnum | null;
+                key: string;
+                value: string;
+                locked?: boolean | null;
+                type?: MetaDataTypeEnum | null;
+            }>;
+        }>;
+    } | null;
+};
+export type GetDirtyProjectQueryVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+}>;
+export type GetDirtyProjectQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        description: string;
+        citation?: string | null;
+        summary: string;
+        updatedOn: string;
+        createdOn: string;
+        deleted: boolean;
+        dirty: boolean;
+        ref: string;
+        bounds?: {
+            __typename?: 'ProjectBounds';
+            id: string;
+            polygonUrl: string;
+        } | null;
+        meta: Array<{
+            __typename?: 'MetaData';
+            ext?: MetaDataExtEnum | null;
+            key: string;
+            value: string;
+            locked?: boolean | null;
+            type?: MetaDataTypeEnum | null;
+        }>;
+    } | null;
+};
+export type DirtyProjectsFragmentFragment = {
+    __typename?: 'Project';
+    id: string;
+    name: string;
+    description: string;
+    citation?: string | null;
+    summary: string;
+    updatedOn: string;
+    createdOn: string;
+    deleted: boolean;
+    dirty: boolean;
+    ref: string;
+    bounds?: {
+        __typename?: 'ProjectBounds';
+        id: string;
+        polygonUrl: string;
+    } | null;
+    meta: Array<{
+        __typename?: 'MetaData';
+        ext?: MetaDataExtEnum | null;
+        key: string;
+        value: string;
+        locked?: boolean | null;
+        type?: MetaDataTypeEnum | null;
+    }>;
+};
+export type Auth_QueryQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type Auth_QueryQuery = {
+    __typename?: 'Query';
+    info?: {
+        __typename?: 'WarehouseInfo';
+        api?: string | null;
+        businessLogic?: string | null;
+        projectFile?: string | null;
+        warehouse?: string | null;
+        xml?: string | null;
+        xsd?: string | null;
+    } | null;
+};
+export type MyProfileQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type MyProfileQuery = {
+    __typename?: 'Query';
+    profile?: {
+        __typename?: 'Profile';
+        id: string;
+        name: string;
+        initialized?: boolean | null;
+    } | null;
+};
+export type DownloadFileQueryVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+    filePath: Scalars['String']['input'];
+}>;
+export type DownloadFileQuery = {
+    __typename?: 'Query';
+    downloadFile?: {
+        __typename?: 'FileDownloadMeta';
+        localPath?: string | null;
+        etag?: string | null;
+        size?: number | null;
+        contentType?: string | null;
+        downloadUrl?: string | null;
+    } | null;
+};
+export type CreateProjectTypeMutationVariables = Exact<{
+    id: Scalars['String']['input'];
+    projectType: ProjectTypeInput;
+}>;
+export type CreateProjectTypeMutation = {
+    __typename?: 'Mutation';
+    createProjectType?: {
+        __typename?: 'ProjectType';
+        id: string;
+    } | null;
+};
+export type UpdateProjectTypeMutationVariables = Exact<{
+    id: Scalars['String']['input'];
+    projectType: ProjectTypeInput;
+}>;
+export type UpdateProjectTypeMutation = {
+    __typename?: 'Mutation';
+    updateProjectType?: {
+        __typename?: 'ProjectType';
+        id: string;
+    } | null;
+};
+export type CreateProjectMutationVariables = Exact<{
+    projectId?: InputMaybe<Scalars['ID']['input']>;
+    orgId?: InputMaybe<Scalars['ID']['input']>;
+    userId?: InputMaybe<Scalars['ID']['input']>;
+    project: ProjectInput;
+    projectTypeId: Scalars['String']['input'];
+    agentId?: InputMaybe<Scalars['ID']['input']>;
+}>;
+export type CreateProjectMutation = {
+    __typename?: 'Mutation';
+    createProject?: {
+        __typename?: 'Project';
+        id: string;
+        ref: string;
+        createdOn: string;
+        updatedOn: string;
+        tags: Array<string>;
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+    } | null;
+};
+export type UpdateProjectMutationVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+    project: ProjectInput;
+    agentId?: InputMaybe<Scalars['ID']['input']>;
+}>;
+export type UpdateProjectMutation = {
+    __typename?: 'Mutation';
+    updateProject?: {
+        __typename?: 'Project';
+        id: string;
+        ref: string;
+        createdOn: string;
+        updatedOn: string;
+        tags: Array<string>;
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+    } | null;
+};
+export type PurgeProjectMutationVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+}>;
+export type PurgeProjectMutation = {
+    __typename?: 'Mutation';
+    purgeProject?: {
+        __typename?: 'MutationResult';
+        ids?: Array<string> | null;
+        error?: string | null;
+        success: boolean;
+        message?: string | null;
+    } | null;
+};
+export type UpdateProfileMutationVariables = Exact<{
+    profile: ProfileInput;
+}>;
+export type UpdateProfileMutation = {
+    __typename?: 'Mutation';
+    updateProfile?: {
+        __typename?: 'Profile';
+        name: string;
+    } | null;
+};
+export type CreateOrganizationMutationVariables = Exact<{
+    organization: OrganizationInput;
+}>;
+export type CreateOrganizationMutation = {
+    __typename?: 'Mutation';
+    createOrganization?: {
+        __typename?: 'Organization';
+        id: string;
+    } | null;
+};
+export type UpdateOrganizationMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    organization: OrganizationInput;
+}>;
+export type UpdateOrganizationMutation = {
+    __typename?: 'Mutation';
+    updateOrganization?: {
+        __typename?: 'Organization';
+        id: string;
+    } | null;
+};
+export type CreateCollectionMutationVariables = Exact<{
+    collection: CollectionInput;
+    orgId?: InputMaybe<Scalars['ID']['input']>;
+}>;
+export type CreateCollectionMutation = {
+    __typename?: 'Mutation';
+    createCollection?: {
+        __typename?: 'Collection';
+        id: string;
+    } | null;
+};
+export type UpdateCollectionMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    organization: OrganizationInput;
+}>;
+export type UpdateCollectionMutation = {
+    __typename?: 'Mutation';
+    updateOrganization?: {
+        __typename?: 'Organization';
+        id: string;
+    } | null;
+};
+export type GetProjectForUploadCheckQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+    dsLimit: Scalars['Int']['input'];
+    dsOffset: Scalars['Int']['input'];
+}>;
+export type GetProjectForUploadCheckQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        summary: string;
+        deleted: boolean;
+        createdOn: string;
+        updatedOn: string;
+        ref: string;
+        tags: Array<string>;
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+        meta: Array<{
+            __typename?: 'MetaData';
+            key: string;
+            value: string;
+            type?: MetaDataTypeEnum | null;
+            locked?: boolean | null;
+            ext?: MetaDataExtEnum | null;
+        }>;
+        createdBy: {
+            __typename?: 'User';
+            id: string;
+            name: string;
+        };
+        updatedBy: {
+            __typename?: 'User';
+            id: string;
+            name: string;
+        };
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        datasets: {
+            __typename?: 'PaginatedDatasets';
+            total: number;
+            items: Array<{
+                __typename?: 'Dataset';
+                id: string;
+                name: string;
+                rsXPath: string;
+            }>;
+        };
+    } | null;
+};
+export type ProjectDownloadQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ProjectDownloadQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        ref: string;
+        tags: Array<string>;
+        createdOn: string;
+        updatedOn: string;
+        deleted: boolean;
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+        meta: Array<{
+            __typename?: 'MetaData';
+            key: string;
+            value: string;
+            type?: MetaDataTypeEnum | null;
+            locked?: boolean | null;
+            ext?: MetaDataExtEnum | null;
+        }>;
+        files: Array<{
+            __typename?: 'FileDownloadMeta';
+            contentType?: string | null;
+            downloadUrl?: string | null;
+            etag?: string | null;
+            localPath?: string | null;
+            size?: number | null;
+        }>;
+    } | null;
+};
+export type ProjectExistsQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ProjectExistsQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        ref: string;
+        deleted: boolean;
+        createdOn: string;
+        updatedOn: string;
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+        meta: Array<{
+            __typename?: 'MetaData';
+            key: string;
+            value: string;
+            type?: MetaDataTypeEnum | null;
+            locked?: boolean | null;
+            ext?: MetaDataExtEnum | null;
+        }>;
+    } | null;
+};
+export type ProjectTree_QueryQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type ProjectTree_QueryQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        deleted: boolean;
+        tree: {
+            __typename?: 'ProjectTree';
+            defaultView?: string | null;
+            description?: string | null;
+            leaves: Array<{
+                __typename?: 'ProjectTreeLeaf';
+                id: number;
+                pid: number;
+                label: string;
+                labelxpath?: string | null;
+                nodeId?: string | null;
+                layerType: ProjectTreeLayerTypeEnum;
+                blLayerId?: string | null;
+                symbology?: string | null;
+                transparency?: number | null;
+                rsXPath: string;
+                lyrName?: string | null;
+            }>;
+            branches: Array<{
+                __typename?: 'ProjectTreeBranch';
+                bid: number;
+                collapsed?: boolean | null;
+                label: string;
+                pid: number;
+            }>;
+            views: Array<{
+                __typename?: 'ProjectTreeView';
+                id: string;
+                name: string;
+                description?: string | null;
+                layers: Array<{
+                    __typename?: 'ProjectTreeViewLayer';
+                    id: string;
+                    visible?: boolean | null;
+                }>;
+            }>;
+        };
+    } | null;
+};
+export type GetProjectForWatcherQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type GetProjectForWatcherQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        createdOn: string;
+        updatedOn: string;
+        ref: string;
+        deleted: boolean;
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+    } | null;
+};
+export type RequestUploadBoundsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type RequestUploadBoundsQuery = {
+    __typename?: 'Query';
+    requestUploadBounds?: {
+        __typename?: 'UploadUrl';
+        fields: JSONObject;
+        token: string;
+        url: string;
+    } | null;
+};
+export type GetProjectFilesForDownloadQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+    dsLimit: Scalars['Int']['input'];
+    dsOffset: Scalars['Int']['input'];
+}>;
+export type GetProjectFilesForDownloadQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        summary: string;
+        deleted: boolean;
+        createdOn: string;
+        updatedOn: string;
+        ref: string;
+        tags: Array<string>;
+        projectType: {
+            __typename?: 'ProjectType';
+            id: string;
+        };
+        meta: Array<{
+            __typename?: 'MetaData';
+            key: string;
+            value: string;
+            type?: MetaDataTypeEnum | null;
+            locked?: boolean | null;
+            ext?: MetaDataExtEnum | null;
+        }>;
+        createdBy: {
+            __typename?: 'User';
+            id: string;
+        };
+        updatedBy: {
+            __typename?: 'User';
+            id: string;
+        };
+        ownedBy: {
+            __typename: 'Organization';
+            id: string;
+            name: string;
+        } | {
+            __typename: 'User';
+            id: string;
+            name: string;
+        };
+        datasets: {
+            __typename?: 'PaginatedDatasets';
+            total: number;
+            items: Array<{
+                __typename?: 'Dataset';
+                id: string;
+                name: string;
+                rsXPath: string;
+            }>;
+        };
+        files: Array<{
+            __typename?: 'FileDownloadMeta';
+            localPath?: string | null;
+            etag?: string | null;
+            size?: number | null;
+            contentType?: string | null;
+            downloadUrl?: string | null;
+        }>;
+    } | null;
+};
+export type RebuildWebTilesMutationVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+    rsXPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+    force?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type RebuildWebTilesMutation = {
+    __typename?: 'Mutation';
+    rebuildWebTiles: {
+        __typename?: 'RebuildWebTilesResponse';
+        skipped?: Array<string> | null;
+        queued?: Array<string> | null;
+    };
+};
+export type ZipRebuildMutationVariables = Exact<{
+    projectId: Scalars['ID']['input'];
+    force?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type ZipRebuildMutation = {
+    __typename?: 'Mutation';
+    zipRebuild?: {
+        __typename?: 'Project';
+        id: string;
+    } | null;
+};
+export type ProjectSearchQueryVariables = Exact<{
+    offset: Scalars['Int']['input'];
+    limit: Scalars['Int']['input'];
+    sort?: InputMaybe<Array<SearchSortEnum>>;
+    params: ProjectSearchParamsInput;
+    minScore?: InputMaybe<Scalars['Float']['input']>;
+    debug?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type ProjectSearchQuery = {
+    __typename?: 'Query';
+    searchProjects: {
+        __typename?: 'SearchProjectPagination';
+        total: number;
+        results: Array<{
+            __typename?: 'SearchProject';
+            score?: number | null;
+            item: {
+                __typename: 'Project';
+                id: string;
+                name: string;
+                deleted: boolean;
+                visibility: ProjectVisibilityEnum;
+                summary: string;
+                projectType: {
+                    __typename?: 'ProjectType';
+                    id: string;
+                    name: string;
+                    logo?: string | null;
+                };
+                meta: Array<{
+                    __typename?: 'MetaData';
+                    ext?: MetaDataExtEnum | null;
+                    key: string;
+                    locked?: boolean | null;
+                    type?: MetaDataTypeEnum | null;
+                    value: string;
+                }>;
+                bounds?: {
+                    __typename?: 'ProjectBounds';
+                    id: string;
+                    geoHash?: string | null;
+                    polygonUrl: string;
+                    bbox: Array<number>;
+                } | null;
+            };
+        }>;
+        stats?: {
+            __typename: 'ProjectSearchMeta';
+            bbox?: Array<number> | null;
+            projectTypes?: JSONObject | null;
+            openSearch?: JSONObject | null;
+        } | {
+            __typename: 'SearchMeta';
+        } | null;
+    };
+};
+export type ValidateProjectQueryVariables = Exact<{
+    xml: Scalars['String']['input'];
+    owner?: InputMaybe<OwnerInput>;
+    files: Array<Scalars['String']['input']>;
+}>;
+export type ValidateProjectQuery = {
+    __typename?: 'Query';
+    validateProject?: {
+        __typename?: 'ProjectValidation';
+        valid?: boolean | null;
+        errors?: Array<{
+            __typename: 'ProjectValidationError';
+            code?: string | null;
+            message: string;
+            severity?: SeverityEnum | null;
+        } | null> | null;
+    } | null;
+};
+export type RequestUploadProjectQueryVariables = Exact<{
+    projectId?: InputMaybe<Scalars['String']['input']>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    files: Array<Scalars['String']['input']>;
+    etags: Array<Scalars['String']['input']>;
+    sizes: Array<Scalars['BigInt']['input']>;
+    noDelete?: InputMaybe<Scalars['Boolean']['input']>;
+    owner?: InputMaybe<OwnerInput>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    visibility?: InputMaybe<ProjectVisibilityEnum>;
+}>;
+export type RequestUploadProjectQuery = {
+    __typename?: 'Query';
+    requestUploadProject?: {
+        __typename: 'UploadProjectRequest';
+        newId?: string | null;
+        create: Array<string>;
+        delete: Array<string>;
+        token: string;
+        update: Array<string>;
+    } | null;
+};
+export type CheckUploadQueryVariables = Exact<{
+    token: Scalars['String']['input'];
+}>;
+export type CheckUploadQuery = {
+    __typename?: 'Query';
+    checkUpload?: {
+        __typename: 'JobStatusObj';
+        data?: JSONObject | null;
+        errors?: Array<string> | null;
+        metaData?: JSONObject | null;
+        percentComplete?: number | null;
+        status: JobStatusEnum;
+    } | null;
+};
+export type RequestUploadProjectFilesUrlQueryVariables = Exact<{
+    files: Array<Scalars['String']['input']>;
+    token: Scalars['String']['input'];
+}>;
+export type RequestUploadProjectFilesUrlQuery = {
+    __typename?: 'Query';
+    requestUploadProjectFilesUrl?: Array<{
+        __typename: 'UploadProjectFileUrls';
+        relPath: string;
+        urls?: Array<string | null> | null;
+    } | null> | null;
+};
+export type FinalizeProjectUploadMutationVariables = Exact<{
+    token: Scalars['String']['input'];
+}>;
+export type FinalizeProjectUploadMutation = {
+    __typename?: 'Mutation';
+    finalizeProjectUpload?: {
+        __typename: 'JobStatusObj';
+    } | null;
+};
+export type RequestUploadImageQueryVariables = Exact<{
+    entityId: Scalars['ID']['input'];
+    entityType: EntitiesWithImagesEnum;
+}>;
+export type RequestUploadImageQuery = {
+    __typename?: 'Query';
+    requestUploadImage?: {
+        __typename?: 'UploadUrl';
+        fields: JSONObject;
+        token: string;
+        url: string;
+    } | null;
+};
+export declare const DirtyProjectsFragment: import("graphql/language/ast").DocumentNode;
+export declare const AdminReIndexOpenSearch: import("graphql/language/ast").DocumentNode;
+export declare const AdminRecreateOpenSearch: import("graphql/language/ast").DocumentNode;
+export declare const DeleteProject: import("graphql/language/ast").DocumentNode;
+export declare const DirtyProjects: import("graphql/language/ast").DocumentNode;
+export declare const GetDirtyProject: import("graphql/language/ast").DocumentNode;
+export declare const Auth_Query: import("graphql/language/ast").DocumentNode;
+export declare const MyProfile: import("graphql/language/ast").DocumentNode;
+export declare const DownloadFile: import("graphql/language/ast").DocumentNode;
+export declare const CreateProjectType: import("graphql/language/ast").DocumentNode;
+export declare const UpdateProjectType: import("graphql/language/ast").DocumentNode;
+export declare const CreateProject: import("graphql/language/ast").DocumentNode;
+export declare const UpdateProject: import("graphql/language/ast").DocumentNode;
+export declare const PurgeProject: import("graphql/language/ast").DocumentNode;
+export declare const UpdateProfile: import("graphql/language/ast").DocumentNode;
+export declare const CreateOrganization: import("graphql/language/ast").DocumentNode;
+export declare const UpdateOrganization: import("graphql/language/ast").DocumentNode;
+export declare const CreateCollection: import("graphql/language/ast").DocumentNode;
+export declare const UpdateCollection: import("graphql/language/ast").DocumentNode;
+export declare const GetProjectForUploadCheck: import("graphql/language/ast").DocumentNode;
+export declare const ProjectDownload: import("graphql/language/ast").DocumentNode;
+export declare const ProjectExists: import("graphql/language/ast").DocumentNode;
+export declare const ProjectTree_Query: import("graphql/language/ast").DocumentNode;
+export declare const GetProjectForWatcher: import("graphql/language/ast").DocumentNode;
+export declare const RequestUploadBounds: import("graphql/language/ast").DocumentNode;
+export declare const GetProjectFilesForDownload: import("graphql/language/ast").DocumentNode;
+export declare const RebuildWebTiles: import("graphql/language/ast").DocumentNode;
+export declare const ZipRebuild: import("graphql/language/ast").DocumentNode;
+export declare const ProjectSearch: import("graphql/language/ast").DocumentNode;
+export declare const ValidateProject: import("graphql/language/ast").DocumentNode;
+export declare const RequestUploadProject: import("graphql/language/ast").DocumentNode;
+export declare const CheckUpload: import("graphql/language/ast").DocumentNode;
+export declare const RequestUploadProjectFilesUrl: import("graphql/language/ast").DocumentNode;
+export declare const FinalizeProjectUpload: import("graphql/language/ast").DocumentNode;
+export declare const RequestUploadImage: import("graphql/language/ast").DocumentNode;