@sassoftware/vi-api/svi-datahub/index.d.ts

Types used in the SAS Visual Investigator API

/* tslint:disable */
/* eslint-disable */
// Generated using typescript-generator version 2.15.527 on 2025-04-09 14:11:38.

export interface SecuredApiMeta {
    experimental?: boolean;
    developmentStartYear?: number;
    developmentEndYear?: number;
    applicationVersion?: string;
    serviceId?: string;
    build?: SecuredBuild;
    apiVersion?: number;
}

export interface SecuredBuild {
    sourceId?: string;
    sourceTimeStamp?: string;
    applicationVersion?: string;
    buildVersion?: string;
    timeStamp?: string;
}

export interface Api extends Serializable {
    version?: number;
    links?: RestRepresentationsLink[];
}

export interface ApiMeta extends Serializable {
    build?: Build;
    experimental?: boolean;
    developmentStartYear?: number;
    developmentEndYear?: number;
    serviceId?: string;
    apiVersion?: number;
}

export interface ResourceMediaType {
    name?: string;
    version?: number;
    deprecated?: boolean;
    docUrl?: string;
}

export interface ResourceMediaTypes {
    mediaTypes?: ResourceMediaType[];
    version?: number;
}

export interface Build extends Serializable {
    sourceId?: string;
    sourceTimeStamp?: string;
    buildVersion?: string;
    applicationVersion?: string;
    timeStamp?: string;
}

export interface Count extends Serializable {
    version?: number;
    value?: number;
}

export interface ErrorCodes {
}

export interface ErrorResponse extends Serializable {
    errorCode?: number;
    message?: string;
    details?: string[];
    remediation?: string;
    errors?: ErrorResponse[];
    id?: string;
    links?: RestRepresentationsLink[];
    version?: number;
    httpStatusCode?: number;
}

export interface RestRepresentationsLink extends Serializable, Comparable<RestRepresentationsLink> {
    method?: string;
    rel?: string;
    href?: string;
    uri?: string;
    type?: string;
    responseType?: string;
    itemType?: string;
    responseItemType?: string;
    title?: string;
}

export interface ModelConstants {
}

export interface ResourceAttributes extends Serializable {
    id?: string;
    version?: number;
    label?: string;
    description?: string;
    links?: RestRepresentationsLink[];
    attributes?: { [index: string]: any };
}

export interface Attribute {
    name?: string;
    value?: any;
    valueList?: any[];
}

export interface ResourceCollection<T> extends Serializable {
    links?: RestRepresentationsLink[];
    name?: string;
    accept?: string;
    start?: number;
    count?: number;
    items?: T[];
    limit?: number;
    version?: number;
}

export interface ResourceProperties extends Serializable {
    properties?: ResourceProperty[];
}

export interface ResourceProperty {
    name?: string;
    value?: string;
}

export interface ResourceSelection extends Serializable {
    id?: string;
    type?: string;
    template?: string;
    resources?: string[];
    links?: RestRepresentationsLink[];
    version?: number;
}

export interface RestRepresentationsResourceSummary extends TrackedResource, Serializable {
    id?: string;
    type?: string;
    name?: string;
    description?: string;
    typeDefName?: string;
    iconUri?: string;
    links?: RestRepresentationsLink[];
    version?: number;
}

export interface SASHeaders {
}

export interface ValidationResponse extends Serializable {
    version?: number;
    error?: ErrorResponse;
    links?: RestRepresentationsLink[];
    valid?: boolean;
}

export interface AbstractModifiableResource extends AbstractResource, ETaggable, TimeTrackedResource, ETagAndLastModifiedProvider {
    createdBy?: string;
    modifiedBy?: string;
}

export interface AbstractResource extends Serializable {
    links?: RestRepresentationsLink[];
    version?: number;
}

export interface ETagAndLastModifiedProvider extends ETaggable, LastModifiedProvider {
}

export interface ETaggable extends Preconditionable {
    etag?: string;
}

export interface LastModifiedProvider extends Preconditionable {
    lastModifiedHeaderDate?: Date;
}

export interface LastModifiedProviderFromModifiedTimeStamp extends LastModifiedProvider {
    modifiedTimeStamp?: Date;
}

export interface Preconditionable {
}

export interface TimeTrackedResource extends LastModifiedProviderFromModifiedTimeStamp {
    creationTimeStamp?: Date;
}

export interface TrackedResource extends Serializable, ETaggable, TimeTrackedResource, ETagAndLastModifiedProvider {
    createdBy?: string;
    modifiedBy?: string;
}

export interface DateDeserializer extends StdDeserializer<Date> {
}

export interface DateSerializer extends StdSerializer<Date> {
}

export interface InstantDeserializer extends JsonDeserializer<Date> {
}

export interface InstantSerializer extends JsonSerializer<Date> {
}

export interface Timestamp {
}

export interface Action extends ActionSummary {
    items?: ActionItem[];
}

export interface ActionItem {
}

export interface Constants {
}

export interface ActionSummary {
    actionId?: string;
    action?: string;
    actionType?: string;
    objectType?: string;
    objectId?: string;
    objectVersion?: string;
    createdBy?: string;
    createdAt?: string;
    links?: RestRepresentationsLink[];
    version?: number;
}

export interface ActionTableValue {
    value?: any;
    type?: ActionTableValueType;
    fieldRestriction?: { [index: string]: any };
}

export interface ActionType {
    actionType?: string;
    localizedMessage?: string;
}

export interface LabelActionItem extends ActionItem {
    type?: ActionItemType;
    label?: string;
    items?: ActionItem[];
    labelType?: LabelValueType;
}

export interface SubActionItem extends ActionItem {
    type?: ActionItemType;
    action?: string;
    items?: ActionItem[];
}

export interface TableActionItem extends ActionItem {
    type?: ActionItemType;
    action?: string;
    headings?: string[];
    rows?: ActionTableValue[][];
}

export interface DataContent {
    "@type": "Document" | "ResolvedEntity" | "DocumentIdentifier" | "DocumentLink" | "TransactionLink";
}

export interface Document extends DataContent {
    "@type": "Document" | "ResolvedEntity";
    objectTypeName?: string;
    objectTypeId?: number;
    objectTypeVersion?: number;
    id?: string;
    createdAt?: Date;
    lastUpdatedAt?: Date;
    validFrom?: Date;
    validTo?: Date;
    fieldValues?: { [index: string]: any };
    fileOperations?: AbstractFileOperationUnion[];
    displayLabel?: string;
}

export interface DocumentIdentifier extends DataContent {
    "@type": "DocumentIdentifier";
    objectTypeName?: string;
    id?: string;
}

export interface DocumentLink extends CommonsDataRelationship {
    "@type": "DocumentLink";
    qualifiedTypeName?: string;
}

export interface EntityReference {
    documentType?: string;
    documentId?: string;
    validFrom?: Date;
    validTo?: Date;
    compoundValues?: string[];
    label?: string;
}

export interface CommonsDataRelationship extends DataContent {
    "@type": "DocumentLink" | "TransactionLink";
    relationshipTypeName?: string;
    relationshipTypeVersion?: number;
    relationshipTypeLabel?: string;
    id?: string;
    createdAt?: Date;
    lastUpdatedAt?: Date;
    validFrom?: Date;
    validTo?: Date;
    displayLabel?: string;
    fromObjectTypeName?: string;
    fromObjectTypeVersion?: number;
    fromObjectId?: string;
    fromObjectDisplayLabel?: string;
    toObjectTypeName?: string;
    toObjectTypeVersion?: number;
    toObjectId?: string;
    toObjectDisplayLabel?: string;
    fieldValues?: { [index: string]: any };
    restrictedFields?: { [index: string]: any };
}

export interface RelationshipIdentifier {
    fullyQualifiedId?: string;
    relationshipName?: string;
    fromObjectName?: string;
    toObjectName?: string;
}

export interface DataResolvedEntity extends Document {
    "@type": "ResolvedEntity";
    label?: string;
    compoundValues?: string[];
    references?: EntityReference[];
}

export interface TransactionLink extends CommonsDataRelationship {
    "@type": "TransactionLink";
}

export interface AbstractFileOperation {
    method?: MethodType;
}

export interface CreateFileOperation extends AbstractFileOperation {
    body?: FileAssociation;
}

export interface DeleteFileOperation extends AbstractFileOperation {
    id?: string;
}

export interface FileAssociation extends ETaggable {
    version?: number;
    id?: string;
    name?: string;
    originalName?: string;
    category?: string;
    location?: string;
    type?: string;
    size?: number;
    description?: string;
    properties?: { [index: string]: any };
    uploadedAt?: Date;
    uploadedBy?: string;
    extractedContent?: string;
    displayOrder?: number;
    link?: boolean;
    isLink?: boolean;
}

export interface UpdateFileOperation extends AbstractFileOperation {
    body?: FileAssociation;
}

export interface ItemPublishResultDTO {
    type?: PublishItemType;
    label?: string;
    successful?: number;
    failed?: number;
    errors?: PublishErrorDTO[];
}

export interface PublishErrorDTO {
    name?: string;
    label?: string;
    message?: string;
}

export interface PublishResolution {
}

export interface SolutionPublishResultDTO {
    solutionName?: string;
    solutionLabel?: string;
    successful?: number;
    failed?: number;
    results?: ItemPublishResultDTO[];
    links?: RestRepresentationsLink[];
}

export interface AccessController {
    allRules?: ResponseEntity<EntityLevelRules[]>;
}

export interface AttachmentController {
}

export interface CatalogController {
}

export interface CommentController {
}

export interface ConditionController {
}

export interface ConditionEvaluationController {
}

export interface ConfigServiceController {
}

export interface ControllerUriConstants {
}

export interface ControllerUtil {
}

export interface DataHubExceptionHandler extends MetahubSharedExceptionHandler {
}

export interface DataServicesController {
}

export interface DatahubHandlerExceptionResolver extends HandlerExceptionResolver, Ordered {
}

export interface DocumentController {
}

export interface DocumentControllerFilterUtil {
}

export interface DocumentFilterUtil {
}

export interface DocumentMetadataController {
}

export interface FileAssociationResponse extends FileAssociation {
    links?: RestRepresentationsLink[];
}

export interface FileController {
}

export interface FilterController {
}

export interface IconController {
    allIcons?: IconDTO[];
}

export interface LinkMetadataController {
}

export interface LinkWithBody<T> extends RestRepresentationsLink {
    body?: T;
}

export interface LockController {
}

export interface MetadataActivityRecorder {
}

export interface MetahubSharedExceptionHandler {
}

export interface PageController {
}

export interface ReferenceListController {
}

export interface RelationshipsController {
}

export interface LinkETaggable extends ETaggable {
}

export interface ResolvedEntityController {
}

export interface ResolvedEntityUtilController {
}

export interface TransactionDataController {
}

export interface TransactionMetadataController {
    allTransactions?: ResponseEntity<TransactionDTO[]>;
}

export interface TraversalController {
}

export interface UtilityServicesController {
    supportedLocales?: LocalizedLocale[];
    defaultLocale?: LocalizedLocale;
}

export interface ActionController {
}

export interface AdminActiveHomepageController {
}

export interface AdminAsyncJobController {
}

export interface AdminCascadingReferenceDataController {
}

export interface AdminControlController {
}

export interface AdminDataStoreController {
}

export interface DataStoreCredentials {
    username?: string;
    password?: string;
}

export interface AdminElementBagController {
}

export interface AdminElementController {
    allElements?: ElementDTO[];
}

export interface AdminEntityController {
}

export interface AdminEntityUtilController {
}

export interface AdminIconController {
    allIcons?: ResponseEntity<IconDTO[]>;
}

export interface AdminMetadataCacheController {
    metadataCacheStatistics?: ResponseEntity<{ [index: string]: any }>;
    clientMetadataCacheStatistics?: ResponseEntity<{ [index: string]: any }>;
}

export interface AdminNldStylingRuleController {
    rulesFromAllSources?: { [index: string]: any };
}

export interface AdminPageBuilderController {
}

export interface contextMappingListWrapper extends ETagAndLastModifiedProvider {
}

export interface AdminReferenceListController {
}

export interface AdminRelationshipController {
    allRelationships?: ResponseEntity<RelationshipDTO[]>;
}

export interface AdminRulesCacheController {
}

export interface AdminStoredObjectController {
}

export interface AdminTemplateController {
}

export interface AdminUtilController {
    allDataStoreNames?: string[];
}

export interface ClientApplicationController {
    allClientApplications?: ResourceCollection<ClientApplication>;
}

export interface SolutionController {
}

export interface TemplateTypeController {
    allTemplateTypes?: ResourceCollection<TemplateType>;
}

export interface AsyncJobException extends DataHubException {
}

export interface RestUtil {
}

export interface AuditableObject extends IdentifiableObject {
    createdBy?: string;
    createdAt?: Date;
    lastUpdatedBy?: string;
    lastUpdatedAt?: Date;
}

export interface CapabilityConstants {
}

export interface ConfigProperty extends Identifiable, NamedObject {
    values?: string[];
}

export interface Constant {
}

export interface ActionHistoryColumns {
}

export interface ConfigPropertyName {
}

export interface QueryName {
}

export interface CoreCascadingReferenceData extends LocalizableObject, NamedObject, SolutionAssignedEntity {
    levels?: CoreReferenceList[];
}

export interface CoreCompound extends AuditableObject, Versioned {
    entity?: CoreEntity;
    elements?: CoreElement[];
}

export interface CoreDataField<O> extends LocalizableObject, Versioned, NamedObject {
    primaryKeyField?: boolean;
    displayIndex?: number;
    primaryKeySeqNo?: number;
    dataType?: any;
    columnName?: string;
    length?: number;
    precision?: number;
    scale?: number;
    unique?: boolean;
    autoGenerated?: boolean;
    required?: boolean;
    systemReserved?: boolean;
    constrainingListName?: string;
    allowMultipleSelections?: boolean;
    readOnly?: boolean;
    userSelectionStrategy?: UserSelectionStrategyType;
    indexedForSearch?: boolean;
    assignedTimeZone?: string;
    displayInTimeZone?: string;
    showTimeZone?: boolean;
    redacted?: boolean;
    useObjectAuthorization?: boolean;
    allowedRedactedFieldGroups?: RedactionRuleEntity[];
    masked?: boolean;
    userGroupSelectionField?: boolean;
    writeOnlyAtCreate?: boolean;
    constrained?: boolean;
    hidden?: boolean;
    owner?: O;
}

export interface CoreDataObject extends LocalizableObject, Versioned, NamedObject, SolutionAssignedEntity, Serializable {
    dataStore?: DataStore;
    tableName?: string;
    tableType?: string;
    cacheTimeoutSecs?: number;
    historyEnabled?: boolean;
    systemReserved?: boolean;
    lastUpdatedAtTimeFieldName?: string;
    createdAtTimeFieldName?: string;
    validFromFieldName?: string;
    validToFieldName?: string;
    allowedRedactedFieldGroups?: RedactionRuleEntity[];
    displayTextFields?: SortableNameReference[];
    fields?: CoreDataField<any>[];
    cached?: boolean;
}

export interface CoreDataObjectWithHistory extends CoreDataObject {
    historyTableName?: string;
    lastUpdatedByUserIdFieldName?: string;
    versionNumberFieldName?: string;
    createFlagHistoryColumnName?: string;
    deleteFlagHistoryColumnName?: string;
    updateFlagHistoryColumnName?: string;
}

export interface CoreElement extends LocalizableObject, Versioned, NamedObject, SolutionAssignedEntity {
    dataType?: any;
    displayable?: boolean;
    compounds?: CoreCompound[];
    mappedFields?: CoreStoredObjectField[];
}

export interface CoreEntity extends LocalizableObject, Versioned, NamedObject, Serializable, SolutionAssignedEntity {
    defaultRegularIcon?: CoreIcon;
    nodeShape?: string;
    nodeColor?: string;
    borderColor?: string;
    borderWidth?: number;
    scale?: number;
    displayTextElements?: SortableNameReference[];
    linkDisplayTextElements?: SortableNameReference[];
    useForNetworkBuild?: boolean;
    temporalSplitting?: boolean;
    compounds?: CoreCompound[];
    nodeDecorations?: NodeDecorationEntity[];
    additionalLabel?: string;
    requiresMultipleContributors?: boolean;
}

export interface CoreIcon extends AuditableObject, Versioned, NamedObject, Serializable, SolutionAssignedEntity {
    type?: IconType;
    bytes?: any;
    imageType?: IconImageType;
}

export interface CoreReferenceList extends LocalizableObject, NamedObject, SolutionAssignedEntity {
    archived?: boolean;
    alphabeticalSort?: boolean;
    maxCodeLength?: number;
    items?: CoreReferenceListField[];
    hierarchyLevel?: number;
    referenceListType?: ReferenceListType;
    parent?: CoreCascadingReferenceData;
}

export interface CoreReferenceListField extends LocalizableObject {
    parentList?: CoreReferenceList;
    code?: string;
    archived?: boolean;
    displayIndex?: number;
    parentCode?: string;
}

export interface CoreRelationship extends CoreDataObjectWithHistory {
    type?: RelationshipType;
    reverseName?: string;
    localizedReverseLabels?: LocalizedLabel[];
    required?: boolean;
    cardinality?: RelationshipCardinality;
    previousCardinality?: RelationshipCardinality;
    jobId?: string;
    fromObject?: CoreStoredObject;
    toObject?: CoreStoredObject;
    toObjectTypeFieldName?: string;
    linkedEntityTypes?: CoreStoredObject[];
    joinKeyFieldName?: string;
    symmetric?: boolean;
    managed?: boolean;
    joinConditions?: BooleanExpressionUnion[];
    cascadeType?: CascadeType;
    sortCriteria?: SortCriteria;
    fields?: CoreRelationshipField[];
    deleteTableName?: string;
    useCustomIndex?: boolean;
    color?: string;
    width?: number;
    dashType?: string;
    styles?: LinkStyleEntity[];
    heterogeneous?: boolean;
    primaryKeyFields?: CoreRelationshipField[];
    internalHeterogeneous?: boolean;
    attributeFields?: CoreRelationshipField[];
    nonAttributeFieldNames?: string[];
    foreignKeyFieldNames?: string[];
    reverseLabel?: string;
    qualifiedName?: string;
    link?: boolean;
    readOnly?: boolean;
}

export interface CoreRelationshipField extends CoreDataField<CoreRelationship> {
    owner?: CoreRelationship;
    summaryDisplayIndex?: number;
    authorizedToRevealMasked?: MaskRevealAuthorizationEntityRelationship[];
}

export interface CoreStoredObject extends CoreDataObjectWithHistory {
    type?: DataObjectType;
    fields?: CoreStoredObjectField[];
    relationshipsFrom?: CoreRelationship[];
    relationshipsTo?: CoreRelationship[];
    transactionsFrom?: CoreTransaction[];
    transactionsTo?: CoreTransaction[];
    linkedRelationshipTypes?: CoreRelationship[];
    defaultRegularIcon?: CoreIcon;
    nodeShape?: string;
    nodeColor?: string;
    markerColor?: string;
    borderColor?: string;
    borderWidth?: number;
    scale?: number;
    elementGroupRoot?: boolean;
    indexedForSearch?: boolean;
    attachmentsIndexedForSearch?: boolean;
    enableCasDistributedDataLoad?: boolean;
    deleteTableName?: string;
    urnFormat?: string;
    urnLength?: number;
    urnStartValue?: number;
    urnType?: UrnType;
    requireSearchBeforeCreate?: boolean;
    mobileOfflineEnabled?: boolean;
    fileCategories?: FileCategoryEntity[];
    styles?: EntityStyleEntity[];
    nodeDecorations?: NodeDecorationEntity[];
    additionalLabel?: string;
    publishCode?: PublishCode;
    fieldMap?: { [index: string]: CoreStoredObjectField };
    primaryKeyFields?: CoreStoredObjectField[];
    quotedDeleteTableName?: string;
    urnsequential?: boolean;
    readOnly?: boolean;
}

export interface CoreStoredObjectField extends CoreDataField<CoreStoredObject> {
    owner?: CoreStoredObject;
    element?: CoreElement;
    requiredCondition?: string;
    requiredConditionType?: ObjectStateType;
    readOnlyCondition?: string;
    readOnlyConditionType?: ObjectStateType;
    cascadingReferenceDataName?: string;
    cascadingReferenceDataFilterByListName?: string;
    cascadingReferenceDataFilterByCode?: string;
    cascadingReferenceDataFilterByField?: string;
    primaryKeyUserSelected?: boolean;
    authorizedToRevealMasked?: MaskRevealAuthorizationEntityStoredObject[];
}

export interface CoreTransaction extends CoreDataObject {
    fromObject?: CoreStoredObject;
    toObject?: CoreStoredObject;
    fields?: CoreTransactionField[];
    fromObjJoinCondition?: BooleanExpressionUnion;
    toObjJoinCondition?: BooleanExpressionUnion;
    fromObjectTypeFieldName?: string;
    toObjectTypeFieldName?: string;
    fromObjectRefFieldName?: string;
    toObjectRefFieldName?: string;
    lineWidthFieldName?: string;
    lineWidthFunctionType?: AggregateFunctionType;
    lineColorFieldName?: string;
    lineColorFunctionType?: AggregateFunctionType;
    heterogeneous?: boolean;
    primaryKeyFields?: CoreDataField<any>[];
    toHeterogeneous?: boolean;
    fromHeterogeneous?: boolean;
    fullHeterogeneous?: boolean;
    fromHeterogeneousAndToObjectIsIndexable?: boolean;
    nonHeterogeneousAndBothSidesAreIndexable?: boolean;
    toHeterogeneousAndFromObjectIsIndexable?: boolean;
}

export interface CoreTransactionField extends CoreDataField<CoreTransaction> {
    owner?: CoreTransaction;
    authorizedToRevealMasked?: MaskRevealAuthorizationEntityTransaction[];
}

export interface DataStore extends AuditableObject, Versioned, NamedObject, ETagAndLastModifiedProvider {
    type?: DataStoreType;
    schemaName?: string;
    assignedTimeZone?: string;
    connectionType?: TYPE;
    host?: string;
    port?: string;
    databaseOrServiceName?: string;
    urlAppendedParameters?: string;
    advancedProperties?: { [index: string]: string };
    poolIntialSize?: number;
    poolMinIdle?: number;
    poolMaxIdle?: number;
    poolMaxActive?: number;
    defaultDataStore?: boolean;
    testOnBorrow?: boolean;
    defaultSchemaName?: string;
}

export interface DatahubPrePersistEventListener extends PersistEventListener {
}

export interface EntityTypeNameAndVersion {
    name?: string;
    id?: number;
    version?: number;
}

export interface EntityTypeNameAndVersionDTO {
    id?: number;
    name?: string;
    version?: number;
}

export interface FeatureConstants {
}

export interface FieldHeader {
    fieldId?: number;
    entityTypeId?: number;
    fieldName?: string;
    columnName?: string;
    fieldDataType?: string;
}

export interface FileCategoryEntity extends Serializable {
    name?: string;
    displayName?: string;
    allowMultiple?: boolean;
    required?: boolean;
    documentLockRequired?: boolean;
}

export interface HistoryInfo {
    historyInfoId?: number;
    itemRefId?: string;
    itemType?: ItemType;
    itemLabel?: string;
    operation?: Operation;
    ownerType?: string;
    ownerId?: string;
    ownerVersion?: string;
}

export interface Identifiable {
    id?: number;
}

export interface IdentifiableObject extends Identifiable, HasGeneratedId {
}

export interface InjectableResource {
}

export interface LocalizableObject extends AuditableObject {
    localizedLabels?: LocalizedLabel[];
    localizedDescriptions?: LocalizedDescription[];
    label?: string;
    description?: string;
}

export interface LocalizedDescription extends AuditableObject, Versioned {
    locale?: Locale;
    description?: string;
}

export interface LocalizedLabel extends AuditableObject, Versioned {
    localeCd?: string;
    locale?: Locale;
    label?: string;
    type?: LabelType;
}

export interface MaskRevealAuthorizationEntity {
    uuid?: string;
    selectionTypeCd?: UserGroupType;
    selectionNm?: string;
}

export interface MaskRevealAuthorizationEntityFactory {
}

export interface MaskRevealAuthorizationEntityRelationship extends MaskRevealAuthorizationEntity {
    coreDataField?: CoreRelationshipField;
}

export interface MaskRevealAuthorizationEntityStoredObject extends MaskRevealAuthorizationEntity {
    coreDataField?: CoreStoredObjectField;
}

export interface MaskRevealAuthorizationEntityTransaction extends MaskRevealAuthorizationEntity {
    coreDataField?: CoreTransactionField;
}

export interface NamedObject {
    name?: string;
}

export interface PrimaryKeySeqNoComparators {
}

export interface CoreDataFieldComparator extends Comparator<CoreDataField<any>> {
}

export interface DataFieldDTOComparator extends Comparator<DataField> {
}

export interface QAuditableObject extends EntityPathBase<AuditableObject> {
    _super?: QIdentifiableObject;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
}

export interface QConfigProperty extends EntityPathBase<ConfigProperty> {
    id?: NumberPath<number>;
    name?: StringPath;
    valueString?: StringPath;
}

export interface QCoreCascadingReferenceData extends EntityPathBase<CoreCascadingReferenceData> {
    _super?: QLocalizableObject;
    assignedSolution?: QSolutionEntity;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    levels?: SetPath<CoreReferenceList, QCoreReferenceList>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
}

export interface QCoreCompound extends EntityPathBase<CoreCompound> {
    _super?: QAuditableObject;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    elements?: ListPath<CoreElement, QCoreElement>;
    entity?: QCoreEntity;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    version?: NumberPath<number>;
}

export interface QCoreDataField extends EntityPathBase<CoreDataField<CoreDataObject>> {
    _super?: QLocalizableObject;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    allowMultipleSelections?: BooleanPath;
    assignedTimeZone?: StringPath;
    autoGenerated?: BooleanPath;
    columnName?: StringPath;
    constrainingListName?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    dataType?: EnumPath<any>;
    displayIndex?: NumberPath<number>;
    displayInTimeZone?: StringPath;
    id?: NumberPath<number>;
    indexedForSearch?: BooleanPath;
    isMasked?: BooleanPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    length?: NumberPath<number>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    precision?: NumberPath<number>;
    primaryKeyField?: BooleanPath;
    primaryKeySeqNo?: NumberPath<number>;
    readOnly?: BooleanPath;
    redacted?: BooleanPath;
    required?: BooleanPath;
    scale?: NumberPath<number>;
    showTimeZone?: BooleanPath;
    systemReserved?: BooleanPath;
    unique?: BooleanPath;
    useObjectAuthorization?: BooleanPath;
    userSelectionStrategy?: EnumPath<UserSelectionStrategyType>;
    version?: NumberPath<number>;
}

export interface QCoreDataObject extends EntityPathBase<CoreDataObject> {
    _super?: QLocalizableObject;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    assignedSolution?: QSolutionEntity;
    cacheTimeoutSecs?: NumberPath<number>;
    createdAt?: DateTimePath<Date>;
    createdAtTimeFieldName?: StringPath;
    createdBy?: StringPath;
    dataStore?: QDataStore;
    displayTextString?: StringPath;
    historyEnabled?: BooleanPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedAtTimeFieldName?: StringPath;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    systemReserved?: BooleanPath;
    tableName?: StringPath;
    validFromFieldName?: StringPath;
    validToFieldName?: StringPath;
    version?: NumberPath<number>;
}

export interface QCoreDataObjectWithHistory extends EntityPathBase<CoreDataObjectWithHistory> {
    _super?: QCoreDataObject;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    assignedSolution?: QSolutionEntity;
    cacheTimeoutSecs?: NumberPath<number>;
    createdAt?: DateTimePath<Date>;
    createdAtTimeFieldName?: StringPath;
    createdBy?: StringPath;
    createFlagHistoryColumnName?: StringPath;
    dataStore?: QDataStore;
    deleteFlagHistoryColumnName?: StringPath;
    displayTextString?: StringPath;
    historyEnabled?: BooleanPath;
    historyTableName?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedAtTimeFieldName?: StringPath;
    lastUpdatedBy?: StringPath;
    lastUpdatedByUserIdFieldName?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    systemReserved?: BooleanPath;
    tableName?: StringPath;
    updateFlagHistoryColumnName?: StringPath;
    validFromFieldName?: StringPath;
    validToFieldName?: StringPath;
    version?: NumberPath<number>;
    versionNumberFieldName?: StringPath;
}

export interface QCoreElement extends EntityPathBase<CoreElement> {
    _super?: QLocalizableObject;
    assignedSolution?: QSolutionEntity;
    compounds?: ListPath<CoreCompound, QCoreCompound>;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    dataType?: EnumPath<any>;
    displayable?: BooleanPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    mappedFields?: ListPath<CoreStoredObjectField, QCoreStoredObjectField>;
    name?: StringPath;
    version?: NumberPath<number>;
}

export interface QCoreEntity extends EntityPathBase<CoreEntity> {
    _super?: QLocalizableObject;
    additionalLabel?: StringPath;
    assignedSolution?: QSolutionEntity;
    borderColor?: StringPath;
    borderWidth?: NumberPath<number>;
    compounds?: ListPath<CoreCompound, QCoreCompound>;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    defaultRegularIcon?: QCoreIcon;
    displayTextString?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    linkDisplayTextString?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    nodeColor?: StringPath;
    nodeDecorations?: ListPath<NodeDecorationEntity, QNodeDecorationEntity>;
    nodeShape?: StringPath;
    requiresMultipleContributors?: BooleanPath;
    scale?: NumberPath<number>;
    temporalSplitting?: BooleanPath;
    useForNetworkBuild?: BooleanPath;
    version?: NumberPath<number>;
}

export interface QCoreIcon extends EntityPathBase<CoreIcon> {
    _super?: QAuditableObject;
    assignedSolution?: QSolutionEntity;
    bytes?: ArrayPath<any, number>;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    imageType?: EnumPath<IconImageType>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    name?: StringPath;
    version?: NumberPath<number>;
}

export interface QCoreReferenceList extends EntityPathBase<CoreReferenceList> {
    _super?: QLocalizableObject;
    alphabeticalSort?: BooleanPath;
    archived?: BooleanPath;
    assignedSolution?: QSolutionEntity;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    hierarchyLevel?: NumberPath<number>;
    id?: NumberPath<number>;
    items?: ListPath<CoreReferenceListField, QCoreReferenceListField>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    maxCodeLength?: NumberPath<number>;
    name?: StringPath;
    parent?: QCoreCascadingReferenceData;
    referenceListType?: EnumPath<ReferenceListType>;
}

export interface QCoreReferenceListField extends EntityPathBase<CoreReferenceListField> {
    _super?: QLocalizableObject;
    archived?: BooleanPath;
    code?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    displayIndex?: NumberPath<number>;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    parentCode?: StringPath;
    parentList?: QCoreReferenceList;
}

export interface QCoreRelationship extends EntityPathBase<CoreRelationship> {
    _super?: QCoreDataObjectWithHistory;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    assignedSolution?: QSolutionEntity;
    cacheTimeoutSecs?: NumberPath<number>;
    cardinality?: EnumPath<RelationshipCardinality>;
    cascadeType?: EnumPath<CascadeType>;
    color?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdAtTimeFieldName?: StringPath;
    createdBy?: StringPath;
    createFlagHistoryColumnName?: StringPath;
    dashType?: StringPath;
    dataStore?: QDataStore;
    deleteFlagHistoryColumnName?: StringPath;
    deleteTableName?: StringPath;
    displayTextString?: StringPath;
    fields?: ListPath<CoreRelationshipField, QCoreRelationshipField>;
    fromObject?: QCoreStoredObject;
    historyEnabled?: BooleanPath;
    historyTableName?: StringPath;
    id?: NumberPath<number>;
    jobId?: StringPath;
    joinCondition1String?: StringPath;
    joinCondition2String?: StringPath;
    joinKeyFieldName?: StringPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedAtTimeFieldName?: StringPath;
    lastUpdatedBy?: StringPath;
    lastUpdatedByUserIdFieldName?: StringPath;
    linkedEntityTypes?: ListPath<CoreStoredObject, QCoreStoredObject>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    localizedReverseLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    managed?: BooleanPath;
    name?: StringPath;
    previousCardinality?: EnumPath<RelationshipCardinality>;
    required?: BooleanPath;
    reverseName?: StringPath;
    sortCriteriaString?: StringPath;
    styles?: ListPath<LinkStyleEntity, QLinkStyleEntity>;
    symmetric?: BooleanPath;
    systemReserved?: BooleanPath;
    tableName?: StringPath;
    toObject?: QCoreStoredObject;
    toObjectTypeFieldName?: StringPath;
    updateFlagHistoryColumnName?: StringPath;
    useCustomIndex?: BooleanPath;
    validFromFieldName?: StringPath;
    validToFieldName?: StringPath;
    version?: NumberPath<number>;
    versionNumberFieldName?: StringPath;
    width?: NumberPath<number>;
}

export interface QCoreRelationshipField extends EntityPathBase<CoreRelationshipField> {
    _super?: QCoreDataField;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    allowMultipleSelections?: BooleanPath;
    assignedTimeZone?: StringPath;
    authorizedToRevealMasked?: ListPath<MaskRevealAuthorizationEntityRelationship, QMaskRevealAuthorizationEntityRelationship>;
    autoGenerated?: BooleanPath;
    columnName?: StringPath;
    constrainingListName?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    dataType?: EnumPath<any>;
    displayIndex?: NumberPath<number>;
    displayInTimeZone?: StringPath;
    hidden?: BooleanPath;
    id?: NumberPath<number>;
    indexedForSearch?: BooleanPath;
    isMasked?: BooleanPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    length?: NumberPath<number>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    owner?: QCoreRelationship;
    precision?: NumberPath<number>;
    primaryKeyField?: BooleanPath;
    primaryKeySeqNo?: NumberPath<number>;
    readOnly?: BooleanPath;
    redacted?: BooleanPath;
    required?: BooleanPath;
    scale?: NumberPath<number>;
    showTimeZone?: BooleanPath;
    summaryDisplayIndex?: NumberPath<number>;
    systemReserved?: BooleanPath;
    unique?: BooleanPath;
    useObjectAuthorization?: BooleanPath;
    userSelectionStrategy?: EnumPath<UserSelectionStrategyType>;
    version?: NumberPath<number>;
    writeOnlyAtCreate?: BooleanPath;
}

export interface QCoreStoredObject extends EntityPathBase<CoreStoredObject> {
    _super?: QCoreDataObjectWithHistory;
    additionalLabel?: StringPath;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    assignedSolution?: QSolutionEntity;
    attachmentsIndexedForSearch?: BooleanPath;
    borderColor?: StringPath;
    borderWidth?: NumberPath<number>;
    cacheTimeoutSecs?: NumberPath<number>;
    createdAt?: DateTimePath<Date>;
    createdAtTimeFieldName?: StringPath;
    createdBy?: StringPath;
    createFlagHistoryColumnName?: StringPath;
    dataStore?: QDataStore;
    defaultRegularIcon?: QCoreIcon;
    deleteFlagHistoryColumnName?: StringPath;
    deleteTableName?: StringPath;
    displayTextString?: StringPath;
    elementGroupRoot?: BooleanPath;
    enableCasDistributedDataLoad?: BooleanPath;
    fields?: ListPath<CoreStoredObjectField, QCoreStoredObjectField>;
    fileCategories?: SetPath<FileCategoryEntity, QFileCategoryEntity>;
    historyEnabled?: BooleanPath;
    historyTableName?: StringPath;
    id?: NumberPath<number>;
    indexedForSearch?: BooleanPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedAtTimeFieldName?: StringPath;
    lastUpdatedBy?: StringPath;
    lastUpdatedByUserIdFieldName?: StringPath;
    linkedRelationshipTypes?: SetPath<CoreRelationship, QCoreRelationship>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    markerColor?: StringPath;
    mobileOfflineEnabled?: BooleanPath;
    name?: StringPath;
    nodeColor?: StringPath;
    nodeDecorations?: ListPath<NodeDecorationEntity, QNodeDecorationEntity>;
    nodeShape?: StringPath;
    publishCode?: EnumPath<PublishCode>;
    relationshipsFrom?: ListPath<CoreRelationship, QCoreRelationship>;
    relationshipsTo?: ListPath<CoreRelationship, QCoreRelationship>;
    requireSearchBeforeCreate?: BooleanPath;
    scale?: NumberPath<number>;
    styles?: ListPath<EntityStyleEntity, QEntityStyleEntity>;
    systemReserved?: BooleanPath;
    tableName?: StringPath;
    transactionsFrom?: ListPath<CoreTransaction, QCoreTransaction>;
    transactionsTo?: ListPath<CoreTransaction, QCoreTransaction>;
    updateFlagHistoryColumnName?: StringPath;
    urnFormat?: StringPath;
    urnLength?: NumberPath<number>;
    urnStartValue?: NumberPath<number>;
    urnType?: EnumPath<UrnType>;
    validFromFieldName?: StringPath;
    validToFieldName?: StringPath;
    version?: NumberPath<number>;
    versionNumberFieldName?: StringPath;
}

export interface QCoreStoredObjectField extends EntityPathBase<CoreStoredObjectField> {
    _super?: QCoreDataField;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    allowMultipleSelections?: BooleanPath;
    assignedTimeZone?: StringPath;
    authorizedToRevealMasked?: ListPath<MaskRevealAuthorizationEntityStoredObject, QMaskRevealAuthorizationEntityStoredObject>;
    autoGenerated?: BooleanPath;
    cascadingReferenceDataFilterByCode?: StringPath;
    cascadingReferenceDataFilterByField?: StringPath;
    cascadingReferenceDataFilterByListName?: StringPath;
    cascadingReferenceDataName?: StringPath;
    columnName?: StringPath;
    constrainingListName?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    dataType?: EnumPath<any>;
    displayIndex?: NumberPath<number>;
    displayInTimeZone?: StringPath;
    element?: QCoreElement;
    id?: NumberPath<number>;
    indexedForSearch?: BooleanPath;
    isMasked?: BooleanPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    length?: NumberPath<number>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    owner?: QCoreStoredObject;
    precision?: NumberPath<number>;
    primaryKeyField?: BooleanPath;
    primaryKeySeqNo?: NumberPath<number>;
    primaryKeyUserSelected?: BooleanPath;
    readOnly?: BooleanPath;
    readOnlyCondition?: StringPath;
    readOnlyConditionType?: EnumPath<ObjectStateType>;
    redacted?: BooleanPath;
    required?: BooleanPath;
    requiredCondition?: StringPath;
    requiredConditionType?: EnumPath<ObjectStateType>;
    scale?: NumberPath<number>;
    showTimeZone?: BooleanPath;
    systemReserved?: BooleanPath;
    unique?: BooleanPath;
    useObjectAuthorization?: BooleanPath;
    userSelectionStrategy?: EnumPath<UserSelectionStrategyType>;
    version?: NumberPath<number>;
}

export interface QCoreTransaction extends EntityPathBase<CoreTransaction> {
    _super?: QCoreDataObject;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    assignedSolution?: QSolutionEntity;
    cacheTimeoutSecs?: NumberPath<number>;
    createdAt?: DateTimePath<Date>;
    createdAtTimeFieldName?: StringPath;
    createdBy?: StringPath;
    dataStore?: QDataStore;
    displayTextString?: StringPath;
    fields?: ListPath<CoreTransactionField, QCoreTransactionField>;
    fromObject?: QCoreStoredObject;
    fromObjectRefFieldName?: StringPath;
    fromObjectTypeFieldName?: StringPath;
    fromObjJoinConditionString?: StringPath;
    historyEnabled?: BooleanPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedAtTimeFieldName?: StringPath;
    lastUpdatedBy?: StringPath;
    lineColorFieldName?: StringPath;
    lineColorFunctionType?: EnumPath<AggregateFunctionType>;
    lineWidthFieldName?: StringPath;
    lineWidthFunctionType?: EnumPath<AggregateFunctionType>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    systemReserved?: BooleanPath;
    tableName?: StringPath;
    toObject?: QCoreStoredObject;
    toObjectRefFieldName?: StringPath;
    toObjectTypeFieldName?: StringPath;
    toObjJoinConditionString?: StringPath;
    validFromFieldName?: StringPath;
    validToFieldName?: StringPath;
    version?: NumberPath<number>;
}

export interface QCoreTransactionField extends EntityPathBase<CoreTransactionField> {
    _super?: QCoreDataField;
    allowedRedactedFieldGroups?: ListPath<RedactionRuleEntity, QRedactionRuleEntity>;
    allowMultipleSelections?: BooleanPath;
    assignedTimeZone?: StringPath;
    authorizedToRevealMasked?: ListPath<MaskRevealAuthorizationEntityTransaction, QMaskRevealAuthorizationEntityTransaction>;
    autoGenerated?: BooleanPath;
    columnName?: StringPath;
    constrainingListName?: StringPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    dataType?: EnumPath<any>;
    displayIndex?: NumberPath<number>;
    displayInTimeZone?: StringPath;
    id?: NumberPath<number>;
    indexedForSearch?: BooleanPath;
    isMasked?: BooleanPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    length?: NumberPath<number>;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    owner?: QCoreTransaction;
    precision?: NumberPath<number>;
    primaryKeyField?: BooleanPath;
    primaryKeySeqNo?: NumberPath<number>;
    readOnly?: BooleanPath;
    redacted?: BooleanPath;
    required?: BooleanPath;
    scale?: NumberPath<number>;
    showTimeZone?: BooleanPath;
    systemReserved?: BooleanPath;
    unique?: BooleanPath;
    useObjectAuthorization?: BooleanPath;
    userSelectionStrategy?: EnumPath<UserSelectionStrategyType>;
    version?: NumberPath<number>;
}

export interface QDataStore extends EntityPathBase<DataStore> {
    _super?: QAuditableObject;
    advancedProperties?: MapPath<string, string, StringPath>;
    assignedTimeZone?: StringPath;
    connectionType?: EnumPath<TYPE>;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    databaseOrServiceName?: StringPath;
    host?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    name?: StringPath;
    poolIntialSize?: NumberPath<number>;
    poolMaxActive?: NumberPath<number>;
    poolMaxIdle?: NumberPath<number>;
    poolMinIdle?: NumberPath<number>;
    poolTestOnBorrow?: BooleanPath;
    port?: StringPath;
    schemaName?: StringPath;
    urlAppendedParameters?: StringPath;
    version?: NumberPath<number>;
}

export interface QFieldHeader extends EntityPathBase<FieldHeader> {
    columnName?: StringPath;
    entityTypeId?: NumberPath<number>;
    fieldDataType?: StringPath;
    fieldId?: NumberPath<number>;
    fieldName?: StringPath;
}

export interface QFileCategoryEntity extends BeanPath<FileCategoryEntity> {
    allowMultiple?: BooleanPath;
    displayName?: StringPath;
    documentLockRequired?: BooleanPath;
    name?: StringPath;
    required?: BooleanPath;
}

export interface QIdentifiableObject extends EntityPathBase<IdentifiableObject> {
    id?: NumberPath<number>;
}

export interface QLocalizableObject extends EntityPathBase<LocalizableObject> {
    _super?: QAuditableObject;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
}

export interface QLocalizedDescription extends EntityPathBase<LocalizedDescription> {
    _super?: QAuditableObject;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    description?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localeCd?: StringPath;
    version?: NumberPath<number>;
}

export interface QLocalizedLabel extends EntityPathBase<LocalizedLabel> {
    _super?: QAuditableObject;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    label?: StringPath;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localeCd?: StringPath;
    version?: NumberPath<number>;
}

export interface QMaskRevealAuthorizationEntity extends EntityPathBase<MaskRevealAuthorizationEntity> {
    selectionNm?: StringPath;
    selectionTypeCd?: EnumPath<UserGroupType>;
    uuid?: StringPath;
}

export interface QMaskRevealAuthorizationEntityRelationship extends EntityPathBase<MaskRevealAuthorizationEntityRelationship> {
    _super?: QMaskRevealAuthorizationEntity;
    coreDataField?: QCoreRelationshipField;
    selectionNm?: StringPath;
    selectionTypeCd?: EnumPath<UserGroupType>;
    uuid?: StringPath;
}

export interface QMaskRevealAuthorizationEntityStoredObject extends EntityPathBase<MaskRevealAuthorizationEntityStoredObject> {
    _super?: QMaskRevealAuthorizationEntity;
    coreDataField?: QCoreStoredObjectField;
    selectionNm?: StringPath;
    selectionTypeCd?: EnumPath<UserGroupType>;
    uuid?: StringPath;
}

export interface QMaskRevealAuthorizationEntityTransaction extends EntityPathBase<MaskRevealAuthorizationEntityTransaction> {
    _super?: QMaskRevealAuthorizationEntity;
    coreDataField?: QCoreTransactionField;
    selectionNm?: StringPath;
    selectionTypeCd?: EnumPath<UserGroupType>;
    uuid?: StringPath;
}

export interface QRedactionRuleEntity extends EntityPathBase<RedactionRuleEntity> {
    groupName?: StringPath;
    ownerId?: NumberPath<number>;
    uuid?: StringPath;
}

export interface QRelationshipTypeHeader extends EntityPathBase<RelationshipTypeHeader> {
    fromObjectId?: NumberPath<number>;
    relationshipId?: NumberPath<number>;
    relationshipName?: StringPath;
    reverseRelationshipName?: StringPath;
    toObjectId?: NumberPath<number>;
}

export interface QSolutionEntity extends EntityPathBase<SolutionEntity> {
    _super?: QLocalizableObject;
    archived?: BooleanPath;
    createdAt?: DateTimePath<Date>;
    createdBy?: StringPath;
    id?: NumberPath<number>;
    lastUpdatedAt?: DateTimePath<Date>;
    lastUpdatedBy?: StringPath;
    localizedDescriptions?: ListPath<LocalizedDescription, QLocalizedDescription>;
    localizedLabels?: ListPath<LocalizedLabel, QLocalizedLabel>;
    name?: StringPath;
    resourceVersion?: NumberPath<number>;
}

export interface QTenantFailure extends EntityPathBase<TenantFailure> {
    dateCreated?: DateTimePath<Date>;
    dateUpdated?: DateTimePath<Date>;
    instanceId?: StringPath;
    stackTrace?: StringPath;
    tenancyState?: StringPath;
    tenantId?: StringPath;
}

export interface RedactionRuleEntity {
    ownerId?: number;
    groupName?: string;
}

export interface RelationshipTypeHeader {
    relationshipId?: number;
    fromObjectId?: