@shapediver/sdk.geometry-api-sdk-v2/dist/client/api.d.ts

SDK to communicate with the Geometry API version 2

import type { Configuration } from './configuration';
import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
import type { RequestArgs } from './base';
import { BaseAPI } from '../base';
export interface CommmonsParameterAsset {
    'id': string;
    'chunk'?: CommonsParameterChunk;
}
export type CommonsBasicParameter = boolean | number | string;
export declare const CommonsComputationStatus: {
    readonly SUCCESS: "success";
    readonly TIMEOUT: "timeout";
    readonly CHECK_CONFIRMED: "checkconfirmed";
    readonly CHECK_DENIED: "checkdenied";
    readonly CHECK_PENDING: "checkpending";
    readonly MAX_COMBINED_ASSET_SIZE_EXCEEDED: "maxcombinedassetsizeexceeded";
    readonly MAX_DB_SIZE_PER_OUTPUT_EXCEEDED: "maxdbsizeperoutputexceeded";
    readonly MAX_PARTS_PER_OUTPUT_EXCEEDED: "maxpartsperoutputexceeded";
    readonly MAX_ASSET_PARTS_PER_OUTPUT_EXCEEDED: "maxassetpartsperoutputexceeded";
    readonly MAX_TRANSFORMATIONS_PER_OUTPUT_EXCEEDED: "maxtransformationsperoutputexceeded";
    readonly MAX_PARTS_EXCEEDED: "maxpartsexceeded";
    readonly MAX_ASSET_PARTS_EXCEEDED: "maxassetpartsexceeded";
    readonly RECOVERABLE_ERROR: "recoverableerror";
    readonly UNRECOVERABLE_ERROR: "unrecoverableerror";
    readonly NO_OUTPUT_DATA_FOR_DEFAULT_PARAMETER_VALUES: "nooutputdatafordefaultparametervalues";
    readonly MODEL_WITHOUT_GEOMETRY_OUTPUT: "modelwithoutgeometryoutput";
    readonly UNKNOWN: "unknown";
};
export type CommonsComputationStatus = typeof CommonsComputationStatus[keyof typeof CommonsComputationStatus];
export interface CommonsGroup {
    'id': string;
    'name': string;
}
export interface CommonsModelBlockingReasons {
    'creditLimit'?: boolean;
    'owner'?: boolean;
}
export declare const CommonsModelStatus: {
    readonly UNKNOWN: "unknown";
    readonly NOT_UPLOADED: "not_uploaded";
    readonly UPLOADED: "uploaded";
    readonly PENDING: "pending";
    readonly CONFIRMED: "confirmed";
    readonly DENIED: "denied";
    readonly DELETED: "deleted";
};
export type CommonsModelStatus = typeof CommonsModelStatus[keyof typeof CommonsModelStatus];
export interface CommonsParameterChunk {
    'id'?: string;
    'name'?: string;
}
export interface CommonsStypeParameter {
    'value'?: string;
    'asset'?: CommmonsParameterAsset;
}
export interface CommonsTicket {
    'accessdomains'?: Array<string>;
    'author'?: boolean;
    'pub': boolean;
    'until': string;
    'use_id2'?: boolean;
}
export declare const CommonsTicketType: {
    readonly BACKEND: "backend";
    readonly NONE: "";
};
export type CommonsTicketType = typeof CommonsTicketType[keyof typeof CommonsTicketType];
export interface NullObj {
    'nullObj': boolean;
}
export declare const QueryComputationStatisticsStatus: {
    readonly SUCCESS: "success";
    readonly TIMEOUT: "timeout";
    readonly OTHER: "other";
    readonly ALL: "*";
};
export type QueryComputationStatisticsStatus = typeof QueryComputationStatisticsStatus[keyof typeof QueryComputationStatisticsStatus];
export declare const QueryComputationStatus: {
    readonly SUCCESS: "success";
    readonly TIMEOUT: "timeout";
    readonly CHECK_CONFIRMED: "checkconfirmed";
    readonly CHECK_DENIED: "checkdenied";
    readonly CHECK_PENDING: "checkpending";
    readonly MAX_COMBINED_ASSET_SIZE_EXCEEDED: "maxcombinedassetsizeexceeded";
    readonly MAX_DB_SIZE_PER_OUTPUT_EXCEEDED: "maxdbsizeperoutputexceeded";
    readonly MAX_PARTS_PER_OUTPUT_EXCEEDED: "maxpartsperoutputexceeded";
    readonly MAX_ASSET_PARTS_PER_OUTPUT_EXCEEDED: "maxassetpartsperoutputexceeded";
    readonly MAX_TRANSFORMATIONS_PER_OUTPUT_EXCEEDED: "maxtransformationsperoutputexceeded";
    readonly MAX_PARTS_EXCEEDED: "maxpartsexceeded";
    readonly MAX_ASSET_PARTS_EXCEEDED: "maxassetpartsexceeded";
    readonly RECOVERABLE_ERROR: "recoverableerror";
    readonly UNRECOVERABLE_ERROR: "unrecoverableerror";
    readonly NO_OUTPUT_DATA_FOR_DEFAULT_PARAMETER_VALUES: "nooutputdatafordefaultparametervalues";
    readonly MODEL_WITHOUT_GEOMETRY_OUTPUT: "modelwithoutgeometryoutput";
    readonly UNKNOWN: "unknown";
};
export type QueryComputationStatus = typeof QueryComputationStatus[keyof typeof QueryComputationStatus];
export declare const QueryComputationType: {
    readonly COMPUTATION: "computation";
    readonly EXPORT: "export";
    readonly LOAD: "load";
    readonly ALL: "*";
};
export type QueryComputationType = typeof QueryComputationType[keyof typeof QueryComputationType];
export declare const QueryGltfConversion: {
    readonly NONE: "none";
    readonly SCENE: "scene";
    readonly USDZ: "usdz";
};
export type QueryGltfConversion = typeof QueryGltfConversion[keyof typeof QueryGltfConversion];
export declare const QueryModelStatus: {
    readonly UNKNOWN: "unknown";
    readonly NOT_UPLOADED: "not_uploaded";
    readonly UPLOADED: "uploaded";
    readonly PENDING: "pending";
    readonly CONFIRMED: "confirmed";
    readonly DENIED: "denied";
    readonly DELETED: "deleted";
};
export type QueryModelStatus = typeof QueryModelStatus[keyof typeof QueryModelStatus];
export declare const QueryOrder: {
    readonly ASC: "asc";
    readonly DESC: "desc";
};
export type QueryOrder = typeof QueryOrder[keyof typeof QueryOrder];
export type ReqAnyCreditMetricId = ReqModelCreditMetricId | ReqModelOrganizationCreditMetricId | ReqModelUserCreditMetricId | ReqOrganizationCreditMetricId | ReqSystemCreditMetricId | ReqUserCreditMetricId;
export interface ReqAuthorizationGroup {
    'models'?: Array<string>;
    'users'?: Array<string>;
    'organizations'?: Array<string>;
}
export type ReqBasicParameter = boolean | number | string;
export interface ReqCache {
    [key: string]: string;
}
export interface ReqConfigure {
    [key: string]: any;
}
export interface ReqCreditMetric {
    'id': ReqAnyCreditMetricId;
    'timestamp'?: Array<string>;
    'timestamp_from'?: string;
    'timestamp_to'?: string;
}
export interface ReqCreditMetrics {
    'parameters': Array<ReqCreditMetric>;
}
export interface ReqCustomization {
    [key: string]: ReqParameterValue;
}
export type ReqCustomizationOrCache = ReqCache | ReqCustomization;
export type ReqCustomizationOrExport = ReqCustomization | ReqExport;
export interface ReqExport {
    'parameters': ReqCustomization;
    'exports': Array<string>;
    'outputs'?: Array<string>;
    'max_wait_time'?: number;
}
export interface ReqExportDefinition {
    'displayname'?: string;
    'group'?: ReqExportDefinitionGroup;
    'hidden'?: boolean;
    'order'?: number;
    'tooltip'?: string;
}
export type ReqExportDefinitionGroup = NullObj | ReqGroup;
export interface ReqExportDefinitions {
    [key: string]: ReqExportDefinition;
}
export type ReqExportOrCache = ReqCache | ReqExport;
export interface ReqFileDefinition {
    'filename'?: string;
    'format': string;
    'size': number;
}
export interface ReqFileUpload {
    [key: string]: ReqFileDefinition;
}
export interface ReqGroup {
    'id': string;
    'name': string;
}
export declare const ReqLogLevel: {
    readonly INFO: "0";
    readonly WARN: "1";
    readonly ERROR: "2";
};
export type ReqLogLevel = typeof ReqLogLevel[keyof typeof ReqLogLevel];
export interface ReqLogMessage {
    'level': ReqLogLevel;
    'message': string;
}
export interface ReqModel {
    'accessdomains'?: Array<string>;
    'allowed_libraries'?: Array<string>;
    'auth_groups'?: Array<string>;
    'backendaccess'?: boolean;
    'blockingReasons'?: ReqModelBlockingReasons;
    'filename'?: string;
    'ftype'?: ReqModelFileType;
    'initial_warmup'?: boolean;
    'id2'?: string;
    'max_comp_time'?: number;
    'max_export_size'?: number;
    'max_idle_minutes'?: number;
    'max_model_size'?: number;
    'max_output_size'?: number;
    'max_texture_size'?: number;
    'max_wait_time'?: number;
    'name'?: string;
    'num_loaded_max'?: number;
    'num_loaded_min'?: number;
    'num_preloaded_min'?: number;
    'org_id'?: string;
    'prev_id'?: string;
    'with_repo'?: boolean;
    'pub'?: boolean;
    'require_iframe'?: boolean;
    'require_token'?: boolean;
    'session_rate_limit'?: number;
    'trust'?: ReqTrustLevel;
    'use_cdn'?: boolean;
    'user_id'?: string;
    'webhook_url'?: string;
    'webhook_token'?: string;
    'deny_scripts'?: boolean;
}
export interface ReqModelBlockingReasons {
    'creditLimit'?: boolean;
    'owner'?: boolean;
}
export interface ReqModelCreditMetricId {
    'modelIds': Array<string>;
}
export declare const ReqModelFileType: {
    readonly GRASSHOPPER_BINARY: "gh";
    readonly GRASSHOPPER_XML: "ghx";
};
export type ReqModelFileType = typeof ReqModelFileType[keyof typeof ReqModelFileType];
export interface ReqModelOrganizationCreditMetricId {
    'modelIds': Array<string>;
    'orgIds': Array<string>;
}
export interface ReqModelState {
    'parameters': ReqCustomization;
    'data'?: {
        [key: string]: any;
    };
    'image'?: ReqFileDefinition;
    'arSceneId'?: string;
}
export interface ReqModelStatistic {
    'modelid': Array<string>;
    'timestamp'?: Array<string>;
    'timestamp_from'?: string;
    'timestamp_to'?: string;
}
export interface ReqModelStatistics {
    'parameters': Array<ReqModelStatistic>;
}
export interface ReqModelUserCreditMetricId {
    'modelIds': Array<string>;
    'userIds': Array<string>;
}
export interface ReqOrganizationCreditMetricId {
    'orgIds': Array<string>;
}
export interface ReqOutputDefinition {
    'displayname'?: string;
    'group'?: ReqOutputDefinitionGroup;
    'hidden'?: boolean;
    'order'?: number;
    'tooltip'?: string;
    'chunks'?: Array<ReqOutputDefinitionChunk>;
}
export interface ReqOutputDefinitionChunk {
    'id': string;
    'displayname'?: string;
    'hidden'?: boolean;
}
export type ReqOutputDefinitionGroup = NullObj | ReqGroup;
export interface ReqOutputDefinitions {
    [key: string]: ReqOutputDefinition;
}
export interface ReqParameterDefinition {
    'displayname'?: string;
    'group'?: ReqParameterDefinitionGroup;
    'hidden'?: boolean;
    'order'?: number;
    'tooltip'?: string;
    'settings'?: object;
}
export type ReqParameterDefinitionGroup = NullObj | ReqGroup;
export interface ReqParameterDefinitions {
    [key: string]: ReqParameterDefinition;
}
export type ReqParameterValue = ReqBasicParameter | ReqStypeParameter;
export interface ReqSdtfDefinition {
    'content_encoding'?: string;
    'content_length': number;
    'content_type': ReqSdtfType;
    'namespace': string;
}
export declare const ReqSdtfType: {
    readonly MODEL_SDTF: "model/vnd.sdtf";
};
export type ReqSdtfType = typeof ReqSdtfType[keyof typeof ReqSdtfType];
export interface ReqStypeParameter {
    'value'?: string;
    'asset'?: CommmonsParameterAsset;
}
export interface ReqSystemCreditMetricId {
    'systems': boolean;
}
export interface ReqTicket {
    'accessdomains'?: Array<string>;
    'author'?: boolean;
    'pub': boolean;
    'until': string;
    'use_id2'?: boolean;
    'type': ReqTicketType;
}
export declare const ReqTicketType: {
    readonly BACKEND: "backend";
    readonly NONE: "";
};
export type ReqTicketType = typeof ReqTicketType[keyof typeof ReqTicketType];
export declare const ReqTrustLevel: {
    readonly UNDEFINED: "";
    readonly NONE: "none";
    readonly FULL: "full";
};
export type ReqTrustLevel = typeof ReqTrustLevel[keyof typeof ReqTrustLevel];
export interface ReqUserCreditMetricId {
    'userIds': Array<string>;
}
export interface ResAction {
    'name': string;
    'title': string;
    'href': string;
    'method': string;
    'template'?: string;
}
export interface ResAllowedWorkerPlugin {
    'id': string;
    'name': string;
    'minVersion': string;
    'maxVersion': string;
    'authorName'?: string;
    'description'?: string;
    'href'?: string;
    'allowFallbackToAssemblyVersion': boolean;
    'checkMajorMinorVersionOnly': boolean;
    'checkIfInstalled': boolean;
    'previousIds': Array<string>;
    'allowedComponents': Array<ResWorkerPluginComponent>;
    'disallowedComponents': Array<ResWorkerPluginComponent>;
}
export interface ResAnalytics {
    'models': Array<ResModelStatistic>;
    'creditMetrics': Array<ResAnyCreditMetric>;
}
export type ResAnyCreditMetric = ResModelCreditMetric | ResModelOrganizationCreditMetric | ResModelUserCreditMetric | ResOrganizationCreditMetric | ResSystemCreditMetric | ResUserCreditMetric;
export interface ResArCreditMetric {
    'credits': number;
}
export interface ResAsset {
    'file'?: {
        [key: string]: ResAssetDefinition;
    };
    'sdtf'?: Array<ResAssetDefinition>;
    'modelState'?: ResAssetDefinition;
}
export interface ResAssetDefinition {
    'id': string;
    'href': string;
    'headers': ResAssetUploadHeaders;
}
export interface ResAssetUploadHeaders {
    'contentDisposition'?: string;
    'contentType': string;
}
export interface ResAuthorizationSettings {
    'ticket'?: ResTicketAuthorization;
    'token'?: ResTokenAuthorization;
}
export interface ResBase {
    'asset'?: ResAsset;
    'list'?: ResList;
    'modelState'?: ResModelStateOrData;
    'system'?: ResSystem;
    'actions'?: Array<ResAction>;
    'analytics'?: ResAnalytics;
    'auth_group'?: string;
    'cleanup'?: Array<ResModelCleanupProcess>;
    'decryptedTicket'?: ResTicket;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'file'?: ResFile;
    'gltf'?: ResGltfUpload;
    'message'?: string;
    'model'?: ResModel;
    'computations'?: Array<ResModelComputation>;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'pagination'?: ResPagination;
    'parameters'?: {
        [key: string]: ResParameter;
    };
    'plugins'?: ResPlugins;
    'sessionId'?: string;
    'setting'?: ResSettings;
    'statistic'?: ResStatistic;
    'templates'?: Array<ResTemplate>;
    'ticket'?: string;
    'version': string;
    'viewer'?: ResViewer;
    'viewerSettingsVersion'?: string;
    'warnings'?: Array<string>;
}
export interface ResBaseAsset {
    'asset'?: ResAsset;
}
export interface ResBaseCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
}
export interface ResBaseList {
    'list'?: ResList;
}
export interface ResBaseModelState {
    'modelState'?: ResModelStateOrData;
}
export interface ResBaseSystem {
    'system'?: ResSystem;
}
export type ResBasicParameter = boolean | number | string;
export interface ResCleanupExports {
    'version': string;
}
export interface ResCleanupOutputs {
    'version': string;
}
export interface ResCleanupTextures {
    'version': string;
}
export interface ResCloseSession {
    'version': string;
}
export interface ResComputationComponent {
    'computed': Array<ResComputedComponent>;
    'computing': Array<ResComputingComponent>;
    'errors': Array<ResErrorComponent>;
    'warnings': Array<ResWarningComponent>;
}
export interface ResComputationComponents {
    'components': ResComputationComponent;
    'count_success'?: number;
    'count_timeout'?: number;
    'changes'?: Array<string>;
}
export interface ResComputationLimits {
    'max_comp_time': number;
    'max_output_size': number;
    'max_export_size': number;
}
export declare const ResComputationStatus: {
    readonly SUCCESS: "success";
    readonly TIMEOUT: "timeout";
    readonly CHECK_CONFIRMED: "checkconfirmed";
    readonly CHECK_DENIED: "checkdenied";
    readonly CHECK_PENDING: "checkpending";
    readonly MAX_COMBINED_ASSET_SIZE_EXCEEDED: "maxcombinedassetsizeexceeded";
    readonly MAX_DB_SIZE_PER_OUTPUT_EXCEEDED: "maxdbsizeperoutputexceeded";
    readonly MAX_PARTS_PER_OUTPUT_EXCEEDED: "maxpartsperoutputexceeded";
    readonly MAX_ASSET_PARTS_PER_OUTPUT_EXCEEDED: "maxassetpartsperoutputexceeded";
    readonly MAX_TRANSFORMATIONS_PER_OUTPUT_EXCEEDED: "maxtransformationsperoutputexceeded";
    readonly MAX_PARTS_EXCEEDED: "maxpartsexceeded";
    readonly MAX_ASSET_PARTS_EXCEEDED: "maxassetpartsexceeded";
    readonly RECOVERABLE_ERROR: "recoverableerror";
    readonly UNRECOVERABLE_ERROR: "unrecoverableerror";
    readonly NO_OUTPUT_DATA_FOR_DEFAULT_PARAMETER_VALUES: "nooutputdatafordefaultparametervalues";
    readonly MODEL_WITHOUT_GEOMETRY_OUTPUT: "modelwithoutgeometryoutput";
    readonly UNKNOWN: "unknown";
};
export type ResComputationStatus = typeof ResComputationStatus[keyof typeof ResComputationStatus];
export interface ResComputeExports {
    'actions'?: Array<ResAction>;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'message'?: string;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'templates'?: Array<ResTemplate>;
    'version': string;
}
export interface ResComputeOutputs {
    'actions'?: Array<ResAction>;
    'message'?: string;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'templates'?: Array<ResTemplate>;
    'version': string;
}
export interface ResComputeSettings {
    'deny_scripts': boolean;
    'ftype': string;
    'initial_warmup': boolean;
    'max_comp_time': number;
    'max_export_size': number;
    'max_idle_minutes': number;
    'max_model_size'?: number;
    'max_output_size': number;
    'max_texture_size'?: number;
    'max_wait_time': number;
    'num_loaded_max': number;
    'num_loaded_min': number;
    'num_preloaded_min': number;
    'session_rate_limit'?: number;
    'trust': string;
}
export interface ResComputedComponent {
    'instance': string;
    'component': string;
    'name': string;
    'nick_name': string;
    'time': number;
}
export interface ResComputingComponent {
    'instance': string;
    'component': string;
    'name': string;
    'nick_name': string;
}
export interface ResCreateAuthorizationGroup {
    'auth_group': string;
    'message'?: string;
    'version': string;
}
export interface ResCreateModel {
    'file': ResFile;
    'message'?: string;
    'model': ResModel;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'version': string;
}
export interface ResCreateModelConfig {
    'version': string;
}
export interface ResCreateModelState {
    'modelState': ResModelState;
    'version': string;
    'asset'?: ResModelStateAsset;
}
export interface ResCreateSessionByModel {
    'actions': Array<ResAction>;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'file': ResFile;
    'message'?: string;
    'model': ResModel;
    'modelState'?: ResModelStateData;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'parameters'?: {
        [key: string]: ResParameter;
    };
    'sessionId': string;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'templates': Array<ResTemplate>;
    'version': string;
    'viewer': ResViewer;
    'viewerSettingsVersion': string;
    'warnings'?: Array<string>;
}
export interface ResCreateSessionByTicket {
    'actions': Array<ResAction>;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'file': ResFile;
    'message'?: string;
    'model': ResModel;
    'modelState'?: ResModelStateData;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'parameters'?: {
        [key: string]: ResParameter;
    };
    'sessionId': string;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'templates': Array<ResTemplate>;
    'version': string;
    'viewer': ResViewer;
    'viewerSettingsVersion': string;
    'warnings'?: Array<string>;
}
export interface ResCreateTicket {
    'file': ResFile;
    'model': ResModel;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'ticket': string;
    'version': string;
}
export interface ResDecryptTicket {
    'decryptedTicket': ResTicket;
    'version': string;
}
export interface ResDefaultCombinedMetric {
    'credits': number;
}
export interface ResDefaultComputationMetric {
    'count': number;
    'credits': number;
    'duration': number;
    'countPerChunks': {
        [key: string]: number;
    };
}
export interface ResDefaultCreditMetric {
    'outputs': ResDefaultOutputMetric;
    'exports': ResDefaultExportMetric;
    'combined': ResDefaultCombinedMetric;
    'sessions': ResDefaultSessionMetric;
    'computations': ResDefaultComputationMetric;
}
export interface ResDefaultExportMetric {
    'credits': number;
}
export interface ResDefaultOutputMetric {
    'credits': number;
}
export interface ResDefaultSessionMetric {
    'count': number;
    'duration': number;
}
export interface ResDeleteFile {
    'version': string;
}
export interface ResDeleteModel {
    'version': string;
}
export interface ResDeleteModelState {
    'version': string;
}
export interface ResDeleteSdtf {
    'version': string;
}
export interface ResError {
    'error': ResErrorType;
    'desc': string;
    'message'?: string;
}
export interface ResErrorComponent {
    'component': string;
    'errors': Array<string>;
    'instance': string;
    'name': string;
    'nick_name': string;
    'warnings': Array<string>;
}
export declare const ResErrorType: {
    readonly ASSERTION_ERROR: "SdAssertionError";
    readonly CACHE_ERROR_GENERIC: "SdCacheErrorGeneric";
    readonly CONNECTOR_ERROR: "SdConnectorError";
    readonly DATABASE_ERROR_GENERIC: "SdDatabaseErrorGeneric";
    readonly EMAILING_ERROR: "SdEmailingError";
    readonly ERROR_ENTITY_NOT_FOUND: "SdErrorEntityNotFound";
    readonly ERROR_FORBIDDEN: "SdErrorForbidden";
    readonly ERROR_GENERIC_CLIENT: "SdErrorGenericClient";
    readonly ERROR_GENERIC_INTERNAL: "SdErrorGenericInternal";
    readonly ERROR_UNAUTHORIZED: "SdErrorUnauthorized";
    readonly ILLEGAL_ARGUMENT_ERROR: "SdIllegalArgumentError";
    readonly JWT_VALIDATION_ERROR: "SdJwtValidationError";
    readonly METHOD_NOT_ALLOWED_ERROR: "SdMethodNotAllowedError";
    readonly MODEL_VALIDATION_ERROR: "SdModelValidationError";
    readonly NOT_ACCEPTABLE: "SdNotAcceptable";
    readonly NOT_FOUND_ERROR: "SdNotFoundError";
    readonly PARAMETER_VALIDATION_ERROR: "SdParameterValidationError";
    readonly RATE_LIMIT_ERROR_GENERIC: "SdRateLimitErrorGeneric";
    readonly REQUEST_TIMEOUT: "SdRequestTimeout";
    readonly REQUEST_VALIDATION_ERROR: "SdRequestValidationError";
    readonly RESOURCE_GONE_ERROR: "SdResourceGoneError";
    readonly SESSION_GONE_ERROR: "SdSessionGoneError";
    readonly SESSION_VALIDATION_ERROR: "SdSessionValidationError";
    readonly STORAGE_ERROR_GENERIC: "SdStorageErrorGeneric";
    readonly TEXTURE_URL_ERROR: "SdTextureUrlError";
    readonly TICKET_VALIDATION_ERROR: "SdTicketValidationError";
    readonly TOKEN_MISSING_ERROR: "SdTokenMissingError";
    readonly TRANSFORM_CONTENT_ARRAY_ERROR: "SdTransformContentArrayError";
    readonly UNCONFIRMED_MODEL_ERROR: "SdUnconfirmedModelError";
    readonly UNKNOWN: "";
};
export type ResErrorType = typeof ResErrorType[keyof typeof ResErrorType];
export interface ResExport {
    'id': string;
    'uid'?: string;
    'name': string;
    'type': ResExportDefinitionType;
    'dependency': Array<string>;
    'group'?: ResExportDefinitionGroup;
    'order'?: number;
    'tooltip'?: string;
    'displayname'?: string;
    'hidden': boolean;
    'version': string;
    'delay'?: number;
    'content'?: Array<ResExportContent>;
    'msg'?: string;
    'filename'?: string;
    'result'?: ResExportResult;
    'status_computation'?: ResComputationStatus;
    'status_collect'?: ResComputationStatus;
}
export interface ResExportContent {
    'format': string;
    'href': string;
    'size'?: number;
    'contentType'?: string;
}
export interface ResExportDefinition {
    'id': string;
    'uid'?: string;
    'name': string;
    'type': ResExportDefinitionType;
    'dependency': Array<string>;
    'group'?: ResExportDefinitionGroup;
    'order'?: number;
    'tooltip'?: string;
    'displayname'?: string;
    'hidden': boolean;
    'version'?: boolean | null;
}
export interface ResExportDefinitionGroup {
    'id': string;
    'name': string;
}
export declare const ResExportDefinitionType: {
    readonly UNKNOWN: "unknown";
    readonly DOWNLOAD: "download";
    readonly EMAIL: "email";
    readonly SHAPEWAYS: "shapeways";
};
export type ResExportDefinitionType = typeof ResExportDefinitionType[keyof typeof ResExportDefinitionType];
export interface ResExportList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export': Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export type ResExportOrDefinition = ResExport | ResExportDefinition;
export interface ResExportResult {
    'msg'?: string;
    'err'?: string;
    'href'?: string;
    'modelId'?: string;
}
export interface ResFile {
    'upload'?: string;
    'download'?: string;
}
export interface ResFileAsset {
    'file': {
        [key: string]: ResAssetDefinition;
    };
    'sdtf'?: Array<ResAssetDefinition>;
    'modelState'?: ResAssetDefinition;
}
export interface ResFileInfo {
    'id': string;
    'parameterId': string;
    'size': number;
    'filename'?: string;
}
export interface ResFileList {
    'file': Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export interface ResGetCachedExports {
    'actions'?: Array<ResAction>;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'message'?: string;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'templates'?: Array<ResTemplate>;
    'version': string;
}
export interface ResGetCachedOutputs {
    'actions'?: Array<ResAction>;
    'message'?: string;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'templates'?: Array<ResTemplate>;
    'version': string;
}
export interface ResGetCleanupStatus {
    'cleanup': Array<ResModelCleanupProcess>;
    'version': string;
}
export interface ResGetCreditMetrics {
    'analytics': ResAnalytics;
    'message'?: string;
    'version': string;
}
export interface ResGetMinionsInfo {
    'version': string;
    'system': ResMinionSystem;
}
export interface ResGetModel {
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'file': ResFile;
    'message'?: string;
    'model': ResModel;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'parameters'?: {
        [key: string]: ResParameter;
    };
    'plugins'?: ResPlugins;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'version': string;
}
export interface ResGetModelComputations {
    'computations': Array<ResModelComputation>;
    'pagination': ResPagination;
    'version': string;
}
export interface ResGetModelConfig {
    'message'?: string;
    'version': string;
    'viewer': ResViewer;
}
export interface ResGetModelOrganizationCreditMetrics {
    'analytics': ResAnalytics;
    'version': string;
}
export interface ResGetModelState {
    'modelState': ResModelState;
    'version': string;
}
export interface ResGetModelStateData {
    'modelState': ResModelStateData;
    'version': string;
}
export interface ResGetModelStatistics {
    'analytics': ResAnalytics;
    'message'?: string;
    'version': string;
}
export interface ResGetModelUserCreditMetrics {
    'analytics': ResAnalytics;
    'version': string;
}
export interface ResGetOrganizationCreditMetrics {
    'analytics': ResAnalytics;
    'version': string;
}
export interface ResGetSessionDefaults {
    'actions': Array<ResAction>;
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
    'message'?: string;
    'model': ResModel;
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
    'parameters'?: {
        [key: string]: ResParameter;
    };
    'sessionId': string;
    'statistic': ResStatistic;
    'templates': Array<ResTemplate>;
    'version': string;
    'viewer': ResViewer;
    'viewerSettingsVersion': string;
}
export interface ResGetUserCreditMetrics {
    'analytics': ResAnalytics;
    'version': string;
}
export interface ResGetWorkersInfo {
    'version': string;
    'system': ResWorkerSystem;
}
export interface ResGltfUpload {
    'href': string;
    'sceneId'?: string;
}
export interface ResInstalledWorkerPlugin {
    'id': string;
    'name': string;
    'version': string;
    'authorName': string;
    'authorContact': string;
    'description': string;
    'assemblyVersion': string;
    'assemblyFullName': string;
    'isCoreLibrary': boolean;
    'license': number;
    'loadingMechanism': number;
    'location': string;
}
export interface ResLimitedCreditMetric {
    'outputs': ResRateLimitedOutputMetric;
    'exports': ResRateLimitedExportMetric;
    'combined': ResRateLimitedCombinedMetric;
    'sessions': ResRateLimitedSessionMetric;
    'computations': ResRateLimitedComputationMetric;
}
export interface ResList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export interface ResListExportVersions {
    'pagination': ResPagination;
    'version': string;
    'list': ResExportList;
}
export interface ResListFiles {
    'message'?: string;
    'pagination': ResPagination;
    'version': string;
    'list': ResFileList;
}
export interface ResListModelStates {
    'pagination': ResPagination;
    'version': string;
    'list': ResModelStateList;
}
export interface ResListModels {
    'pagination': ResPagination;
    'version': string;
    'list': ResModelList;
}
export interface ResListOutputVersions {
    'pagination': ResPagination;
    'version': string;
    'list': ResOutputList;
}
export interface ResListSdtfs {
    'message'?: string;
    'pagination': ResPagination;
    'version': string;
    'list': ResSdtfList;
}
export interface ResListTextures {
    'pagination': ResPagination;
    'version': string;
    'list': ResTextureList;
}
export interface ResLoadingCreditMetric {
    'credits': number;
    'count': number;
}
export interface ResLogMessage {
    'version': string;
}
export interface ResMinionInfo {
    'instances': {
        [key: string]: ResMinionProcess;
    };
    'tasks': {
        [key: string]: ResMinionTask;
    };
}
export interface ResMinionProcess {
    'tasks': {
        [key: string]: ResMinionTask;
    };
}
export interface ResMinionSystem {
    'minions': ResMinionInfo;
    'workers'?: ResWorkerInfo;
}
export interface ResMinionTask {
    'avgDuration': number;
    'maxDuration': number;
    'avgIntervalDiff': number;
    'maxIntervalDiff': number;
    'interval': number;
    'latest': string;
    'count': number;
}
export interface ResModel {
    'allowed_libraries'?: Array<string>;
    'backlinkurl'?: string;
    'checkurl'?: string;
    'createdate'?: string;
    'documentid'?: string;
    'filename'?: string;
    'id': string;
    'id2'?: string;
    'msg'?: string;
    'name'?: string;
    'org_id'?: string;
    'stat': ResModelStatus;
    'user_id'?: string;
    'webhook_url'?: string;
    'webhook_token'?: string;
}
export interface ResModelBlockingReasons {
    'creditLimit': boolean;
    'owner': boolean;
    'pluginPermission': boolean;
}
export interface ResModelCleanupProcess {
    'type': ResModelCleanupProcessType;
    'timestamp_enqueued': string;
    'total'?: number;
    'deleted'?: number;
}
export declare const ResModelCleanupProcessType: {
    readonly DELETE_EXPORT_VERSION: "delete_export_version";
    readonly DELETE_MODEL_TEXTURE: "delete_model_texture";
    readonly DELETE_OUTPUT_VERSION: "delete_output_version";
};
export type ResModelCleanupProcessType = typeof ResModelCleanupProcessType[keyof typeof ResModelCleanupProcessType];
export interface ResModelComputation {
    'id': string;
    'timestamp': number;
    'timestamp_str': string;
    'compute_request_id': string;
    'exports': {
        [key: string]: string;
    };
    'outputs': {
        [key: string]: string;
    };
    'params': object;
    'stats': ResModelComputationStats;
    'status': ResComputationStatus;
    'timestamp_fin': string;
    'timestamp_req': string;
    'timestamp_req_iso': string;
    'timestamp_resp': string;
    'msg'?: string;
    'limit'?: ResComputationLimits;
    'credits'?: number;
}
export interface ResModelComputationStats {
    'size_assets'?: number;
    'size_assets_storage'?: number;
    'time_completion': number;
    'time_model_download': number;
    'time_model_open': number;
    'time_processing': number;
    'time_check_stored': number;
    'time_check_loaded': number;
    'time_storage'?: number;
    'time_solver': number;
    'time_solver_collect'?: number;
    'time_solver_ext': number;
    'time_wait': number;
    'time_cache_outputs'?: number;
    'model'?: ResComputationComponents;
    'cpu_time_check_stored'?: number;
    'cpu_time_check_loaded'?: number;
    'cpu_time_storage'?: number;
    'cpu_time_model_download'?: number;
    'cpu_time_model_open'?: number;
    'cpu_time_solver'?: number;
    'cpu_time_solver_collect'?: number;
    'cpu_time_solver_ext'?: number;
    'cpu_time_cache_outputs'?: number;
    'time_model_prepare'?: number;
    'cpu_time_model_prepare'?: number;
}
export interface ResModelCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'modelId': string;
    'userId'?: boolean | null;
    'orgId'?: boolean | null;
}
export interface ResModelList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model': Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export interface ResModelOrganizationCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'modelId': string;
    'orgId': string;
}
export interface ResModelSettings {
    'use_cdn'?: boolean;
    'cdn_supported'?: boolean;
    'blockingReasons'?: ResModelBlockingReasons;
}
export interface ResModelState {
    'parameters': {
        [key: string]: ResParameterValue;
    };
    'data'?: {
        [key: string]: any;
    };
    'id': string;
    'modelId': string;
    'createdate': string;
    'imageUrl'?: string;
}
export interface ResModelStateAsset {
    'file'?: {
        [key: string]: ResAssetDefinition;
    };
    'sdtf'?: Array<ResAssetDefinition>;
    'modelState': ResAssetDefinition;
}
export interface ResModelStateData {
    'parameters': {
        [key: string]: ResParameterValue;
    };
    'data'?: {
        [key: string]: any;
    };
}
export interface ResModelStateInfo {
    'id': string;
    'parameters': {
        [key: string]: ResParameterValue;
    };
    'hasImage': boolean;
    'hasGltf': boolean;
    'hasUsdz': boolean;
}
export interface ResModelStateList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState': Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export type ResModelStateOrData = ResModelState | ResModelStateData;
export interface ResModelStatistic {
    'modelid': string;
    'timestamp': string;
    'isCompilationDone': boolean;
    'count': number;
    'billableCount': number;
    'duration': ResOnDurationStatistic;
    'app': ResOnDurationStatistic;
    'backend': ResOnDurationStatistic;
    'embedded': ResOnDurationStatistic;
    'desktop': ResOnDurationStatistic;
    'customize': ResOnActionStatistic;
    'export': ResOnActionStatistic;
}
export declare const ResModelStatus: {
    readonly UNKNOWN: "unknown";
    readonly NOT_UPLOADED: "not_uploaded";
    readonly UPLOADED: "uploaded";
    readonly PENDING: "pending";
    readonly CONFIRMED: "confirmed";
    readonly DENIED: "denied";
    readonly DELETED: "deleted";
};
export type ResModelStatus = typeof ResModelStatus[keyof typeof ResModelStatus];
export interface ResModelUserCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'modelId': string;
    'userId': string;
}
export interface ResOnActionStatistic {
    'count': number;
    'billableCount': number;
    'min': number;
    'max': number;
    'avg': number;
    'sum': number;
    'sumApp': number;
    'sumBackend': number;
    'sumEmbedded': number;
    'sumDesktop': number;
}
export interface ResOnDurationStatistic {
    'count': number;
    'billableCount': number;
    'min': number;
    'max': number;
    'avg': number;
    'sum': number;
}
export interface ResOrganizationCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'modelId'?: boolean | null;
    'orgId': string;
}
export interface ResOutput {
    'id': string;
    'uid'?: string;
    'name': string;
    'material'?: string;
    'chunks'?: Array<ResOutputChunk>;
    'dependency': Array<string>;
    'group'?: ResOutputDefinitionGroup;
    'order'?: number;
    'tooltip'?: string;
    'displayname'?: string;
    'hidden': boolean;
    'version': string;
    'delay'?: number;
    'content'?: Array<ResOutputContent>;
    'bbmin'?: Array<number>;
    'bbmax'?: Array<number>;
    'msg'?: string;
    'status_computation'?: ResComputationStatus;
    'status_collect'?: ResComputationStatus;
}
export interface ResOutputChunk {
    'id': string;
    'name': string;
    'typeHint': string;
    'tooltip'?: string;
    'displayname': string;
    'hidden': boolean;
}
export interface ResOutputContent {
    'href'?: string;
    'size'?: number;
    'name'?: string;
    'transformations'?: Array<Array<number>>;
    'format': string;
    'msg'?: string;
    'data'?: any;
    'contentType'?: string;
}
export interface ResOutputDefinition {
    'id': string;
    'uid'?: string;
    'name': string;
    'material'?: string;
    'chunks'?: Array<ResOutputChunk>;
    'dependency': Array<string>;
    'group'?: ResOutputDefinitionGroup;
    'order'?: number;
    'tooltip'?: string;
    'displayname'?: string;
    'hidden': boolean;
    'version'?: boolean | null;
}
export interface ResOutputDefinitionGroup {
    'id': string;
    'name': string;
}
export interface ResOutputList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output': Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export type ResOutputOrDefinition = ResOutput | ResOutputDefinition;
export interface ResPagination {
    'limit': number;
    'next_offset'?: string;
}
export interface ResParameter {
    'id': string;
    'choices'?: Array<string>;
    'decimalplaces'?: number;
    'defval'?: string;
    'expression'?: string;
    'format'?: Array<string>;
    'min'?: number;
    'max'?: number;
    'umin'?: number;
    'umax'?: number;
    'vmin'?: number;
    'vmax'?: number;
    'interval'?: number;
    'name': string;
    'type': ResParameterType;
    'visualization'?: ResVisualizationType;
    'structure'?: ResStructureType;
    'group'?: ResParameterGroup;
    'hint'?: string;
    'order'?: number;
    'tooltip'?: string;
    'displayname'?: string;
    'hidden': boolean;
    'settings'?: object;
}
export interface ResParameterGroup {
    'id': string;
    'name': string;
}
export declare const ResParameterType: {
    readonly S_BITMAP: "sBitmap";
    readonly S_BOOL: "sBool";
    readonly S_BOX: "sBox";
    readonly S_BREP: "sBrep";
    readonly S_CIRCLE: "sCircle";
    readonly S_COLOR: "sColor";
    readonly S_CURVE: "sCurve";
    readonly S_DOMAIN: "sDomain";
    readonly S_DOMAIN_2D: "sDomain2D";
    readonly S_INTEGER: "sInteger";
    readonly S_LINE: "sLine";
    readonly S_MESH: "sMesh";
    readonly S_NUMBER: "sNumber";
    readonly S_PLANE: "sPlane";
    readonly S_POINT: "sPoint";
    readonly S_RECTANGLE: "sRectangle";
    readonly S_STRING: "sString";
    readonly S_SUBDIV: "sSubdiv";
    readonly S_SURFACE: "sSurface";
    readonly S_TIME: "sTime";
    readonly S_VECTOR: "sVector";
    readonly BOOL: "Bool";
    readonly COLOR: "Color";
    readonly DRAWING: "Drawing";
    readonly EVEN: "Even";
    readonly FILE: "File";
    readonly FLOAT: "Float";
    readonly INT: "Int";
    readonly INTERACTION: "Interaction";
    readonly ODD: "Odd";
    readonly STRING: "String";
    readonly STRINGLIST: "StringList";
    readonly TIME: "Time";
    readonly UNKNOWN: "unknown";
};
export type ResParameterType = typeof ResParameterType[keyof typeof ResParameterType];
export type ResParameterValue = ResBasicParameter | ResStypeParameter;
export interface ResPartActions {
    'actions'?: Array<ResAction>;
}
export interface ResPartAnalytics {
    'analytics'?: ResAnalytics;
}
export interface ResPartAuthorizationGroup {
    'auth_group'?: string;
}
export interface ResPartCleanup {
    'cleanup'?: Array<ResModelCleanupProcess>;
}
export interface ResPartDecryptedTicket {
    'decryptedTicket'?: ResTicket;
}
export interface ResPartExports {
    'exports'?: {
        [key: string]: ResExportOrDefinition;
    };
}
export interface ResPartFile {
    'file'?: ResFile;
}
export interface ResPartGltfUpload {
    'gltf'?: ResGltfUpload;
}
export interface ResPartMessage {
    'message'?: string;
}
export interface ResPartModel {
    'model'?: ResModel;
}
export interface ResPartModelComputation {
    'computations'?: Array<ResModelComputation>;
}
export interface ResPartModelState {
    'modelState'?: ResModelState;
}
export interface ResPartModelStateData {
    'modelState'?: ResModelStateData;
}
export interface ResPartOutputs {
    'outputs'?: {
        [key: string]: ResOutputOrDefinition;
    };
}
export interface ResPartPagination {
    'pagination'?: ResPagination;
}
export interface ResPartParameters {
    'parameters'?: {
        [key: string]: ResParameter;
    };
}
export interface ResPartPlugins {
    'plugins'?: ResPlugins;
}
export interface ResPartSessionId {
    'sessionId'?: string;
}
export interface ResPartSetting {
    'setting'?: ResSettings;
}
export interface ResPartStatistic {
    'statistic'?: ResStatistic;
}
export interface ResPartTemplates {
    'templates'?: Array<ResTemplate>;
}
export interface ResPartTicket {
    'ticket'?: string;
}
export interface ResPartVersion {
    'version'?: string;
}
export interface ResPartViewer {
    'viewer'?: ResViewer;
}
export interface ResPartViewerSettingsVersion {
    'viewerSettingsVersion'?: string;
}
export interface ResPartWarnings {
    'warnings'?: Array<string>;
}
export interface ResPlugins {
    'libraries'?: Array<ResPluginsLibrary>;
}
export interface ResPluginsLibrary {
    'id': string;
    'version': string;
    'name': string;
    'author': string;
    'assemblyFullName'?: string;
    'assemblyVersion'?: string;
}
export interface ResRateLimitedCombinedMetric {
    'credits': number;
}
export interface ResRateLimitedComputationMetric {
    'count': number;
    'credits': number;
    'duration': number;
    'countPerChunks': {
        [key: string]: number;
    };
}
export interface ResRateLimitedExportMetric {
    'credits': number;
}
export interface ResRateLimitedOutputMetric {
    'count': number;
}
export interface ResRateLimitedSessionMetric {
    'count': number;
    'credits': number;
    'duration': number;
}
export interface ResSdtfAsset {
    'file'?: {
        [key: string]: ResAssetDefinition;
    };
    'sdtf': Array<ResAssetDefinition>;
    'modelState'?: ResAssetDefinition;
}
export interface ResSdtfInfo {
    'id': string;
    'namespace': string;
    'size': number;
}
export interface ResSdtfList {
    'file'?: Array<ResFileInfo>;
    'sdtf': Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture'?: Array<ResTexture>;
}
export interface ResSettings {
    'auth'?: ResAuthorizationSettings;
    'compute'?: ResComputeSettings;
    'model'?: ResModelSettings;
}
export interface ResStatistic {
    'comptime'?: number;
    'lastsession'?: string;
    'lastview'?: string;
    'memUsage'?: number;
    'numcomp'?: number;
    'numsessions'?: number;
    'requesttime'?: number;
    'size'?: number;
}
export declare const ResStructureType: {
    readonly ITEM: "item";
    readonly LIST: "list";
    readonly TREE: "tree";
};
export type ResStructureType = typeof ResStructureType[keyof typeof ResStructureType];
export interface ResStypeParameter {
    'value'?: string;
    'asset'?: CommmonsParameterAsset;
}
export interface ResSystem {
    'minions'?: ResMinionInfo;
    'workers'?: ResWorkerInfo;
}
export interface ResSystemCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'system': boolean;
}
export interface ResTemplate {
    'name': string;
    'title': string;
    'data': object;
}
export interface ResTexture {
    'modelId': string;
    'textureId': string;
    'url'?: string;
    'width'?: number;
    'height'?: number;
    'isAssetAvailable': boolean;
}
export interface ResTextureList {
    'file'?: Array<ResFileInfo>;
    'sdtf'?: Array<ResSdtfInfo>;
    'model'?: Array<ResModel>;
    'modelState'?: Array<ResModelStateInfo>;
    'output'?: Array<ResOutput>;
    'export'?: Array<ResExport>;
    'texture': Array<ResTexture>;
}
export interface ResTicket {
    'accessdomains': Array<string>;
    'author': boolean;
    'pub': boolean;
    'until': string;
    'use_id2': boolean;
    'type': ResTicketType;
    'model_id': string;
}
export interface ResTicketAuthorization {
    'accessdomains': Array<string>;
    'backendaccess': boolean;
    'pub': boolean;
}
export declare const ResTicketType: {
    readonly BACKEND: "backend";
    readonly NONE: "";
};
export type ResTicketType = typeof ResTicketType[keyof typeof ResTicketType];
export interface ResTokenAuthorization {
    'auth_groups'?: Array<string>;
    'require_iframe'?: boolean;
    'require_token'?: boolean;
}
export interface ResUpdateExportDefinitions {
    'version': string;
}
export interface ResUpdateModel {
    'file': ResFile;
    'message'?: string;
    'model': ResModel;
    'setting': ResSettings;
    'statistic': ResStatistic;
    'version': string;
}
export interface ResUpdateModelConfig {
    'version': string;
}
export interface ResUpdateOutputDefinitions {
    'version': string;
}
export interface ResUpdateParameterDefaultValues {
    'version': string;
}
export interface ResUpdateParameterDefinitions {
    'version': string;
}
export interface ResUploadFile {
    'message'?: string;
    'version': string;
    'asset': ResFileAsset;
}
export interface ResUploadGltf {
    'gltf': ResGltfUpload;
    'version': string;
}
export interface ResUploadSdtf {
    'message'?: string;
    'version': string;
    'asset': ResSdtfAsset;
}
export interface ResUserCreditMetric {
    'timestamp': string;
    'isCompilationDone': boolean;
    'ar': ResArCreditMetric;
    'loading': ResLoadingCreditMetric;
    'limited': ResLimitedCreditMetric;
    'default': ResDefaultCreditMetric;
    'modelId'?: boolean | null;
    'userId': string;
}
export interface ResViewer {
    'config': {
        [key: string]: any;
    };
}
export declare const ResVisualizationType: {
    readonly UNKNOWN: "unknown";
    readonly BUTTON: "button";
    readonly CALENDAR: "calendar";
    readonly CHECKLIST: "checklist";
    readonly CLOCK: "clock";
    readonly CYCLE: "cycle";
    readonly DIAL: "dial";
    readonly DROPDOWN: "dropdown";
    readonly GEOMETRY: "geometry";
    readonly IMAGE: "image";
    readonly SEQUENCE: "sequence";
    readonly SLIDER: "slider";
    readonly SWATCH: "swatch";
    readonly TEXT: "text";
    readonly TOGGLE: "toggle";
};
export type ResVisualizationType = typeof ResVisualizationType[keyof typeof ResVisualizationType];
export interface ResWarningComponent {
    'component'?: string;
    'instance': string;
    'name': string;
    'nick_name': string;
    'warnings': Array<string>;
}
export interface ResWorkerInfo {
    'grasshopperVersion': string;
    'plugins': ResWorkerPlugins;
    'rhinoVersion': string;
    'shapeDiverVersion': string;
}
export interface ResWorkerPluginComponent {
    'id': string;
    'name': string;
}
export interface ResWorkerPlugins {
    'installed': Array<ResInstalledWorkerPlugin>;
    'allowed': Array<ResAllowedWorkerPlugin>;
    'inconsistent': Array<string>;
}
export interface ResWorkerSystem {
    'minions'?: ResMinionInfo;
    'workers': ResWorkerInfo;
}
export declare const AnalyticsApiAxiosParamCreator: (configuration?: Configuration) => {
    getCreditMetrics: (reqCreditMetrics: ReqCreditMetrics, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    getModelOrganizationCreditMetrics: (timestamp: string, orgId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    getModelStatistics: (reqModelStatistics: ReqModelStatistics, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    getModelUserCreditMetrics: (timestamp: string, userId: string, options?: RawAxiosRe