@sassoftware/vi-api/svi-sand/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-07 09:10:59.

export interface ApplicationSetting extends ResponsesErrorResponse {
    name?: string;
    value?: any;
    links?: Link[];
}

export interface SandConfig {
    types?: { [index: string]: SandType };
    links?: Link[];
}

export interface SandField {
    displayName?: string;
    type?: FieldType;
    options?: { [index: string]: any };
    innerFields?: { [index: string]: SandField };
}

export interface SandIndex {
    type?: string;
    name?: string;
    links?: Link[];
}

export interface SandType extends ResponsesErrorResponse {
    solution?: string;
    name?: string;
    displayName?: string;
    category?: TypeCategory;
    fields?: { [index: string]: SandField };
    options?: { [index: string]: any };
    config?: SandConfiguration;
    links?: Link[];
}

export interface Analyzer {
    solution?: string;
    name?: string;
    displayName?: string;
    links?: Link[];
}

export interface AnalyzerConfiguration extends Serializable {
    search?: string;
    facet?: string;
    sort?: string;
    languageTags?: string[];
    icuFilter?: string;
    minShingleSize?: number;
    maxShingleSize?: number;
    phoneticEncoder?: string;
    synonymsPath?: string;
    synonyms?: string[];
}

export interface Synonym {
    terms?: string;
}

export interface AnalyticsLocale {
    name?: string;
    nativeName?: string;
    tag?: string;
}

export interface AnalyticsResult extends Serializable {
    phrase?: string;
    frequencyCount?: number;
    weight?: number;
    objectIds?: ObjectId[];
    aliases?: AnalyticsResult[];
}

export interface ExplorationLevel {
    category?: ResultCategory;
    phrase?: string;
    nextLevel?: ExplorationLevel;
}

export interface Identity extends Serializable {
    name?: string;
    frequencyCount?: number;
    aliases?: Identity[];
}

export interface SankeyLink {
    fromNode?: number;
    toNode?: number;
    frequencyCount?: number;
    objectIds?: ObjectId[];
}

export interface SankeyNode extends AnalyticsResult {
    identifier?: number;
    category?: ResultCategory;
}

export interface CentralityMetrics {
    version?: number;
    id?: string;
    degree?: number;
    eigen?: number;
    close?: number;
    between?: number;
    influence1?: number;
    influence2?: number;
}

export interface CentralityEdge {
    version?: number;
    id?: string;
    source?: string;
    target?: string;
}

export interface CentralityNetwork {
    version?: number;
    edges?: CentralityEdge[];
}

export interface EventConfiguration {
    root?: string;
    fields?: Fields;
    requiredFields?: string[];
}

export interface Fields {
    category?: string;
    label?: string;
    description?: string;
    pointTimestamp?: string;
    intervalStartTimestamp?: string;
    intervalEndTimestamp?: string;
    longitude?: string;
    latitude?: string;
    geoJson?: string;
}

export interface FieldsConfiguration {
    fields?: string[];
}

export interface LabelConfiguration {
    template?: string;
    values?: string[];
}

export interface SandConfiguration {
    summary?: SummaryConfiguration;
    graph?: FieldsConfiguration;
    table?: FieldsConfiguration;
    facets?: FacetConfigUnion[];
    textAnalytics?: TextAnalyticsConfiguration;
    events?: EventConfiguration[];
    label?: LabelConfiguration;
    description?: LabelConfiguration;
}

export interface SummaryConfiguration extends FieldsConfiguration {
    highlighting?: { [index: string]: HighlightingConfiguration };
}

export interface HighlightingConfiguration {
    highlighter?: string;
    fragmentSize?: number;
    fragments?: number;
}

export interface TextAnalyticsConfiguration extends FieldsConfiguration {
    fromField?: string;
    toFields?: string[];
}

export interface DateRangeFacetConfig extends FacetConfig {
    type: "dateRange";
    accuracy?: DateTimeAccuracy;
    filter?: RangeFilterConfig;
    ranges?: DateRange[];
}

export interface FacetConfig {
    type: "dateRange" | "range" | "terms" | "type";
    field?: string;
}

export interface NumericalRangeFacetConfig extends FacetConfig {
    type: "range";
    filter?: RangeFilterConfig;
    ranges?: NumericalRange[];
}

export interface RangeFilterConfig {
    displayFormat?: string;
    allowExact?: boolean;
    allowRange?: boolean;
    fromType?: FromType;
    toType?: ToType;
}

export interface TermsFacetConfig extends FacetConfig {
    type: "terms" | "type";
    limit?: number;
    displayLimit?: number;
    minDocCount?: number;
    orderBy?: string;
    orderDirection?: string;
    calculateCounts?: boolean;
    allowUserEnteredFilters?: boolean;
}

export interface TypeFacetConfig extends TermsFacetConfig {
    type: "type";
}

export interface AbstractFacet {
    type: "dateRange" | "range" | "terms" | "type";
    hitCount?: number;
    selectedHitCount?: number;
}

export interface AbstractFacetWithField<F> extends AbstractFacet {
    type: "dateRange" | "range" | "terms";
    field?: string;
    fieldLabel?: string;
    userEnteredFilters?: F[];
}

export interface DateRangeFacet extends AbstractFacetWithField<DateRangeFilter> {
    type: "dateRange";
    min?: string;
    max?: string;
    accuracy?: DateTimeAccuracy;
    filter?: RangeFilterConfig;
    ranges?: DateFacetRange[];
}

export interface DateFacetRange extends DateRange {
    hitCount?: number;
    selectedHitCount?: number;
    selected?: boolean;
}

export interface FacetVisitor<T> {
}

export interface NumericalRangeFacet extends AbstractFacetWithField<NumericalRangeFilter> {
    type: "range";
    min?: number;
    max?: number;
    filter?: RangeFilterConfig;
    ranges?: NumericalFacetRange[];
}

export interface NumericalFacetRange extends NumericalRange {
    hitCount?: number;
    selectedHitCount?: number;
    selected?: boolean;
}

export interface TermsFacet extends AbstractFacetWithField<TermsFilter> {
    type: "terms";
    buckets?: TermsBucket[];
    displayLimit?: number;
}

export interface TermsBucket {
    term?: any;
    hitCount?: number;
    selectedHitCount?: number;
    selected?: boolean;
}

export interface TypeFacet extends AbstractFacet {
    type: "type";
    buckets?: TypeBucket[];
    displayLimit?: number;
}

export interface TypeBucket {
    type?: string;
    typeLabel?: string;
    hitCount?: number;
    selectedHitCount?: number;
    selected?: boolean;
}

export interface MaskedFieldConfiguration {
    type?: MaskedFieldType;
}

export interface AbstractCompositeFilter extends AbstractFilter {
    type: "and" | "or";
    filters?: AbstractFilterUnion[];
}

export interface AbstractFilter {
    type: "and" | "or" | "dateRange" | "range" | "box" | "polygon" | "radius" | "shape" | "not" | "query" | "terms" | "type";
}

export interface AbstractRangeFilter<V> extends AbstractFilter {
    type: "dateRange" | "range";
    field?: string;
    gt?: V;
    gte?: V;
    lt?: V;
    lte?: V;
}

export interface AndFilter extends AbstractCompositeFilter {
    type: "and";
}

export interface DateRangeFilter extends AbstractRangeFilter<string> {
    type: "dateRange";
    accuracy?: DateTimeAccuracy;
}

export interface FilterVisitor<T> {
}

export interface MapBoundedBoxFilter extends AbstractFilter {
    type: "box";
    coordinates?: number[][];
    topLeft?: Coordinate;
    bottomRight?: Coordinate;
}

export interface MapBoundedPolygonFilter extends AbstractFilter {
    type: "polygon";
    coordinates?: number[][];
    points?: Coordinate[];
}

export interface MapRadiusFilter extends AbstractFilter {
    type: "radius";
    radius?: string;
    coordinates?: number[];
    centre?: Coordinate;
}

export interface MapShapeFilter extends AbstractFilter {
    type: "shape";
    relation?: MapRelation;
    shape?: { [index: string]: any };
    id?: string;
}

export interface NotFilter extends AbstractFilter {
    type: "not";
    filter?: AbstractFilterUnion;
}

export interface NumericalRangeFilter extends AbstractRangeFilter<number> {
    type: "range";
}

export interface OrFilter extends AbstractCompositeFilter {
    type: "or";
}

export interface QueryFilter extends AbstractFilter {
    type: "query";
    query?: AbstractQueryUnion;
}

export interface TermsFilter extends AbstractFilter {
    type: "terms";
    field?: string;
    objectType?: string;
    terms?: any[];
}

export interface TypeFilter extends AbstractFilter {
    type: "type";
    types?: string[];
}

export interface Coordinate {
    longitude?: number;
    latitude?: number;
}

export interface MapCluster {
    geohash?: string;
    count?: number;
    selectedCount?: number;
    bounds?: number[][];
}

export interface MapShape {
    solution?: string;
    id?: string;
    name?: string;
    group?: string;
    shape?: { [index: string]: any };
    links?: Link[];
}

export interface Edge extends Endpoint {
    endpointType: "Edge";
    endpoints?: EndpointUnion[];
    subtype?: string;
    label?: string;
    validFrom?: string;
    validTo?: string;
    fields?: SummaryFieldValue[];
    style?: RelationshipStyle;
}

export interface Endpoint {
    endpointType: "Edge" | "Extended";
    type?: string;
    id?: string;
    compoundValues?: string[];
}

export interface ExtendedVertex extends Vertex {
    vertexType: "Extended";
    adjacent?: number;
    degree?: number;
    fields?: SummaryFieldValue[];
    selected?: boolean;
    adjacentByType?: { [index: string]: number };
    degreeByType?: { [index: string]: number };
}

export interface Graph extends ResponsesErrorResponse {
    counts?: Counts;
    vertices?: VertexUnion[];
    edges?: Edge[];
    expansionLimit?: number;
    expansionLimitExceeded?: ObjectId[];
}

export interface Counts {
    vertices?: number;
    edges?: number;
}

export interface Path {
    endpoints?: EndpointUnion[];
}

export interface Vertex extends Endpoint {
    vertexType: "Extended";
    typeLabel?: string;
    label?: string;
    attachmentsCount?: number;
    validFrom?: string;
    validTo?: string;
    style?: EntityStyle;
}

export interface ChildEntityHighlighting extends ChildEntityHighlightingParameters {
    count?: number;
    childObjects?: ChildObjectHighlighting[];
}

export interface ChildEntityHighlightingParameters {
    start?: number;
    limit?: number;
}

export interface ChildObjectHighlighting {
    id?: string;
    name?: string;
    highlighting?: { [index: string]: any[] };
    maskedFields?: { [index: string]: MaskedFieldConfiguration };
}

export interface ObjectId extends Serializable {
    type?: string;
    id?: string;
}

export interface TypeName extends Serializable {
    name?: string;
    systemType?: boolean;
}

export interface DocOrder extends Order {
    type: "doc";
    direction?: OrderDirection;
}

export interface FieldOrder extends Order {
    type: "field";
    fields?: Field[];
}

export interface Field {
    name?: string;
    entityType?: string;
    direction?: OrderDirection;
}

export interface Order {
    type: "doc" | "field" | "score";
}

export interface ScoreOrder extends Order {
    type: "score";
    direction?: OrderDirection;
}

export interface AbstractQuery {
    type: "and" | "compound" | "endpoint" | "object" | "or" | "text";
}

export interface AndQuery extends AbstractQuery {
    type: "and";
    queries?: AbstractQueryUnion[];
}

export interface CompoundQuery extends AbstractQuery {
    type: "compound";
    compoundValues?: string[];
}

export interface EndpointQuery extends AbstractQuery {
    type: "endpoint";
    endpoints?: ObjectId[];
}

export interface ObjectQuery extends AbstractQuery {
    type: "object";
    objectIds?: ObjectId[];
}

export interface OrQuery extends AbstractQuery {
    type: "or";
    queries?: AbstractQueryUnion[];
}

export interface QueryVisitor<T> {
}

export interface TextQuery extends AbstractQuery {
    type: "text";
    text?: string;
    language?: string;
    modes?: QueryMode[];
}

export interface DateRange extends Range<string> {
}

export interface DateRangeBuilder {
}

export interface NumericalRange extends Range<number> {
}

export interface NumericalRangeBuilder {
}

export interface Range<V> {
    description?: string;
    id?: string;
    gt?: V;
    gte?: V;
    lt?: V;
    lte?: V;
}

export interface AnalyticsExploreRepresentation {
    level?: ExplorationLevel;
}

export interface AnalyticsRepresentation extends QueryRepresentation {
    categories?: ResultCategory[];
    fields?: string[];
    fromField?: string;
    toFields?: string[];
    excludes?: { [index: string]: string[] };
    identities?: { [index: string]: Identity[] };
    maxResultsPerCategory?: number;
    locale?: string;
}

export interface AnalyticsSankeyRepresentation extends AnalyticsExploreRepresentation {
    fromCategory?: ResultCategory;
    toCategory?: ResultCategory;
    fromAndTo?: boolean;
    maxLinks?: number;
}

export interface GraphRepresentation {
    vertexTypes?: string[];
    edgeTypes?: string[];
    query?: AbstractQueryUnion;
    filter?: AbstractFilterUnion;
    selection?: Selection;
}

export interface HighlightRepresentation {
    type?: string;
    id?: string;
    query?: AbstractQueryUnion;
    includeFieldHighlighting?: boolean;
    defaultChildEntityLimit?: number;
    childEntityHighlightingParameters?: { [index: string]: ChildEntityHighlightingParameters };
}

export interface OperationRepresentation {
    operation?: OperationType;
    parameters?: { [index: string]: any };
}

export interface PathsRepresentation extends QueryRepresentation {
    type?: string;
    id?: string;
    filter?: AbstractFilterUnion;
    nextLevel?: PathLevelRepresentation;
}

export interface PathLevelRepresentation {
    vertexTypes?: string[];
    edgeTypes?: string[];
    vertexFilter?: AbstractFilterUnion;
    edgeFilter?: AbstractFilterUnion;
    nextLevel?: PathLevelRepresentation;
}

export interface QueryRepresentation {
    types?: string[];
    query?: AbstractQueryUnion;
}

export interface RelatedObjectsRepresentation {
    startTypes?: string[];
    startQuery?: AbstractQueryUnion;
    startFilter?: AbstractFilterUnion;
    endTypes?: string[];
    endQuery?: AbstractQueryUnion;
    endFilter?: AbstractFilterUnion;
    hops?: number;
}

export interface SearchRepresentation extends QueryRepresentation {
    filter?: AbstractFilterUnion;
    selection?: Selection;
    visualizations?: { [index: string]: VisualizationRepresentationUnion };
}

export interface TraversalRepresentation {
    vertexTypes?: string[];
    edgeTypes?: string[];
    query?: AbstractQueryUnion;
    filter?: AbstractFilterUnion;
    vertexFilter?: AbstractFilterUnion;
    edgeFilter?: AbstractFilterUnion;
    depth?: number;
    extendedFormat?: boolean;
    graphObjectIds?: ObjectId[];
    graphCompoundValues?: string[];
}

export interface AnalyticsCategoriesResponse extends ResponsesErrorResponse {
    identifier?: string;
    level?: ExplorationLevel;
    categories?: ResultCategory[];
    fromAndTo?: boolean;
    links?: Link[];
}

export interface AnalyticsIdentitiesResponse extends ResponsesErrorResponse {
    identifier?: string;
    identities?: { [index: string]: Identity[] };
    links?: Link[];
}

export interface AnalyticsJobResponse extends ResponsesErrorResponse {
    identifier?: string;
    state?: JobState;
    types?: string[];
    query?: AbstractQueryUnion;
    categories?: ResultCategory[];
    fields?: string[];
    fromField?: string;
    toFields?: string[];
    excludes?: { [index: string]: string[] };
    identities?: { [index: string]: Identity[] };
    maxResultsPerCategory?: number;
    locale?: string;
    links?: Link[];
}

export interface AnalyticsResultsResponse {
    identifier?: string;
    level?: ExplorationLevel;
    results?: AnalyticsResult[];
    links?: Link[];
}

export interface AnalyticsSankeyResponse {
    identifier?: string;
    level?: ExplorationLevel;
    fromCategory?: ResultCategory;
    toCategory?: ResultCategory;
    fromAndTo?: boolean;
    maxLinks?: number;
    sankeyNodes?: SankeyNode[];
    sankeyLinks?: SankeyLink[];
    links?: Link[];
}

export interface ResponsesErrorResponse {
    errors?: RepresentationsErrorResponse[];
}

export interface HighlightResponse extends ResponsesErrorResponse {
    type?: string;
    id?: string;
    query?: AbstractQueryUnion;
    includeFieldHighlighting?: boolean;
    defaultChildEntityLimit?: number;
    fieldHighlighting?: { [index: string]: any[] };
    childEntityHighlighting?: { [index: string]: ChildEntityHighlighting };
    maskedFields?: { [index: string]: MaskedFieldConfiguration };
}

export interface IndexFormatUpgradeResponse extends IndexFormatVersionResponse {
    upgradeRequired?: boolean;
}

export interface IndexFormatVersionResponse {
    indexFormatVersion?: number;
}

export interface OperationResponse extends OperationRepresentation {
    results?: { [index: string]: any };
}

export interface SearchResponse extends ResponsesErrorResponse {
    types?: string[];
    query?: AbstractQueryUnion;
    visualizations?: { [index: string]: VisualizationResponseUnion };
}

export interface SynonymCollectionResponse extends ResourceCollection<Synonym> {
    errors?: RepresentationsErrorResponse[];
}

export interface Selection {
    filter?: AbstractFilterUnion;
    include?: ManualSelection;
    exclude?: ManualSelection;
}

export interface ManualSelection {
    query?: string;
    objectIds?: ObjectId[];
    compoundValues?: string[];
}

export interface EntityStyle {
    iconName?: string;
    markerColor?: string;
    backgroundColor?: string;
    shape?: string;
    scale?: number;
    additionalLabel?: string;
    borderWidth?: number;
    borderColor?: string;
    indicatorIcons?: IndicatorIcon[];
}

export interface IndicatorIcon {
    name?: string;
    position?: string;
}

export interface RelationshipStyle {
    color?: string;
    width?: number;
    dashType?: string;
}

export interface EntitySummary extends ResultSummary {
    summaryType: "object";
    attachmentsCount?: number;
}

export interface ResolvedEntitySummary extends ResultSummary {
    summaryType: "entity";
    compoundValues?: string[];
}

export interface ResultSummary {
    summaryType: "object" | "entity";
    id?: string;
    type?: string;
    typeLabel?: string;
    label?: string;
    fields?: SummaryFieldValue[];
    highlighting?: { [index: string]: string[] };
    selected?: boolean;
}

export interface SummaryFieldValue {
    name?: string;
    fieldName?: string;
    type?: FieldType;
    value?: any;
    masked?: MaskedFieldConfiguration;
}

export interface TableColumnHeading {
    field?: string;
    label?: string;
    type?: FieldType;
    masked?: MaskedFieldConfiguration;
}

export interface ClusterSwimLaneEntry extends SwimLaneEntry {
    entryType: "cluster";
    label?: string;
}

export interface ObjectSwimLaneEntry extends SwimLaneEntry {
    entryType: "object";
    eventId?: string;
    eventCategory?: string;
    eventLabel?: string;
    eventDescription?: string;
}

export interface SwimLane {
    id?: string;
    label?: string;
    description?: string;
    attachmentsCount?: number;
    objectTypeLabel?: string;
    selected?: boolean;
    objectId?: string;
    objectType?: string;
}

export interface SwimLaneEntry {
    entryType: "cluster" | "object";
    group?: string;
    startTimestamp?: string;
    endTimestamp?: string;
}

export interface TimebarInterval {
    start?: string;
    hitCount?: number;
}

export interface RestClientUtil {
}

export interface EntityFields {
    entityName?: string;
    fieldNames?: string[];
}

export interface FacetsVisualizationRepresentation extends VisualizationRepresentation {
    type: "facets";
    mode?: FacetMode;
    types?: string[];
}

export interface FacetsVisualizationResponse extends VisualizationResponse {
    type: "facets";
    mode?: FacetMode;
    facets?: TypeSpecificFacets[];
    include?: ManualSelection;
    exclude?: ManualSelection;
}

export interface TypeSpecificFacets {
    objectType?: string;
    objectTypeLabel?: string;
    facets?: AbstractFacetUnion[];
    userEnteredFilters?: AbstractFilterUnion[];
}

export interface HitsVisualizationRepresentation extends VisualizationRepresentation {
    type: "hits";
}

export interface HitsVisualizationResponse extends VisualizationResponse {
    type: "hits";
    hitCount?: number;
    hitsPerType?: TypeBucket[];
}

export interface MapClusterVisualizationResponse extends MapVisualizationResponse {
    type: "mapCluster";
    clusters?: MapCluster[];
}

export interface MapFeatureVisualizationRepresentation extends VisualizationRepresentation {
    type: "mapFeature";
    lat?: number;
    lon?: number;
    maxEvents?: number;
}

export interface MapFeatureVisualizationResponse extends VisualizationResponse {
    type: "mapFeature";
    lat?: number;
    lon?: number;
    maxEvents?: number;
    features?: { [index: string]: any };
}

export interface MapVisualizationRepresentation extends VisualizationRepresentation {
    type: "map";
    view?: number[][];
    maxFeatures?: number;
    maxEvents?: number;
}

export interface MapVisualizationResponse extends VisualizationResponse {
    type: "map" | "mapCluster";
    view?: number[][];
    maxFeatures?: number;
    maxEvents?: number;
    serviceMode?: MapServiceMode;
    hitCount?: number;
    eventCount?: number;
    featureCount?: number;
    approxGlobalFeatureCount?: number;
    features?: { [index: string]: any };
}

export interface PagedVisualizationRepresentation extends VisualizationRepresentation {
    type: "PagedVisualizationRepresentation" | "summary" | "table" | "timeline";
    start?: number;
    limit?: number;
    order?: OrderUnion;
}

export interface PagedVisualizationResponse extends VisualizationResponse {
    type: "PagedVisualizationResponse" | "summary" | "table" | "timeline";
    start?: number;
    limit?: number;
    order?: OrderUnion;
    hitCount?: number;
}

export interface SummaryVisualizationRepresentation extends PagedVisualizationRepresentation {
    type: "summary";
    fields?: EntityFields[];
}

export interface SummaryVisualizationResponse extends PagedVisualizationResponse {
    type: "summary";
    results?: ResultSummaryUnion[];
}

export interface TableVisualizationRepresentation extends PagedVisualizationRepresentation {
    type: "table";
    fields?: EntityFields[];
}

export interface TableVisualizationResponse extends PagedVisualizationResponse {
    type: "table";
    columnHeadings?: TableColumnHeading[];
    data?: { [index: string]: any }[];
}

export interface TimebarVisualizationRepresentation extends VisualizationRepresentation {
    type: "timebar";
    startTimestamp?: string;
    endTimestamp?: string;
    intervalCount?: number;
    geoEventsRequired?: boolean;
}

export interface TimebarVisualizationResponse extends VisualizationResponse {
    type: "timebar";
    intervalCount?: number;
    geoEventsRequired?: boolean;
    hitCount?: number;
    eventCount?: number;
    globalMinTime?: string;
    globalMaxTime?: string;
    interval?: string;
    intervalSize?: number;
    timebarIntervals?: TimebarInterval[];
}

export interface TimelineVisualizationRepresentation extends PagedVisualizationRepresentation {
    type: "timeline";
    startTimestamp?: string;
    endTimestamp?: string;
    intervalCount?: number;
    minimumClusterSize?: number;
    paddingFactor?: number;
}

export interface TimelineVisualizationResponse extends PagedVisualizationResponse {
    type: "timeline";
    intervalCount?: number;
    minimumClusterSize?: number;
    paddingFactor?: number;
    eventCount?: number;
    globalMinTime?: string;
    globalMaxTime?: string;
    minTime?: string;
    maxTime?: string;
    interval?: DateTimeInterval;
    swimLanes?: SwimLane[];
    swimLaneEntries?: SwimLaneEntryUnion[];
}

export interface VisualizationRepresentation {
    type: "facets" | "hits" | "mapFeature" | "map" | "PagedVisualizationRepresentation" | "summary" | "table" | "timeline" | "timebar";
}

export interface VisualizationResponse {
    type: "facets" | "hits" | "mapFeature" | "map" | "mapCluster" | "PagedVisualizationResponse" | "summary" | "table" | "timeline" | "timebar";
}

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

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

export interface Serializable {
}

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

export interface Comparable<T> {
}

export type OperationType = "refreshConfiguration" | "makeIndexSearchable" | "refreshSecurityRules";

export type JobState = "pending" | "running" | "completed" | "completedWithErrors" | "cancelled" | "failed";

export type ResultCategory = "unigram" | "bigram" | "trigram" | "person" | "organization" | "location" | "significantTerm" | "topic" | "invalid";

export type FromType = "gt" | "gte";

export type ToType = "lt" | "lte";

export type DateTimeAccuracy = "oneHundredYear" | "fiftyYear" | "tenYear" | "year" | "month" | "day" | "hour" | "minute" | "second" | "millisecond";

export type DateTimeInterval = "oneHundredYear" | "fiftyYear" | "tenYear" | "year" | "quarter" | "month" | "week" | "day" | "hour" | "minute" | "second";

export type FieldType = "boolean" | "date" | "double" | "float" | "geoPoint" | "geoShape" | "integer" | "long" | "nested" | "object" | "text";

export type MaskedFieldType = "full" | "partial" | "none";

export type TextFieldFeature = "search" | "facet" | "sort" | "html" | "email";

export type MapRelation = "contains" | "disjoint" | "intersects" | "within";

export type MapServiceMode = "global" | "viewport" | "clusters" | "clustersPostQuery";

export type TypeCategory = "alert" | "entity" | "entityRelationship" | "resolvedEntity" | "resolvedEntityRelationship" | "shape" | "socialRelationship" | "transactionRelationship";

export type OrderDirection = "ascending" | "descending";

export type QueryMode = "standard" | "phonetic" | "synonym";

export type FacetMode = "filter" | "selection";

export type FacetConfigUnion = TermsFacetConfig | NumericalRangeFacetConfig | DateRangeFacetConfig | TypeFacetConfig;

export type AbstractFacetUnion = TypeFacet | TermsFacet | NumericalRangeFacet | DateRangeFacet;

export type AbstractFilterUnion = TermsFilter | NumericalRangeFilter | DateRangeFilter | TypeFilter | MapRadiusFilter | MapBoundedBoxFilter | MapBoundedPolygonFilter | MapShapeFilter | QueryFilter | AndFilter | OrFilter | NotFilter;

export type EndpointUnion = Edge | Vertex | ExtendedVertex;

export type VertexUnion = ExtendedVertex;

export type OrderUnion = ScoreOrder | DocOrder | FieldOrder;

export type AbstractQueryUnion = TextQuery | ObjectQuery | AndQuery | OrQuery | EndpointQuery | CompoundQuery;

export type ResultSummaryUnion = EntitySummary | ResolvedEntitySummary;

export type SwimLaneEntryUnion = ClusterSwimLaneEntry | ObjectSwimLaneEntry;

export type VisualizationRepresentationUnion = HitsVisualizationRepresentation | SummaryVisualizationRepresentation | TableVisualizationRepresentation | TimelineVisualizationRepresentation | TimebarVisualizationRepresentation | MapVisualizationRepresentation | MapFeatureVisualizationRepresentation | FacetsVisualizationRepresentation;

export type VisualizationResponseUnion = HitsVisualizationResponse | SummaryVisualizationResponse | TableVisualizationResponse | TimelineVisualizationResponse | TimebarVisualizationResponse | MapVisualizationResponse | MapFeatureVisualizationResponse | MapClusterVisualizationResponse | FacetsVisualizationResponse;