@servicestack/ui/shared.d.ts

TypeScript Definitions for ServiceStack built-in UI's

import { ApiResult } from './client';

export interface IReturn<T> {
    createResponse(): T;
}
export interface IReturnVoid {
    createResponse(): void;
}
export interface IHasSessionId {
    sessionId: string;
}
export interface IHasBearerToken {
    bearerToken: string;
}
export interface IGet {
}
export interface IPost {
}
export interface IPut {
}
export interface IDelete {
}
export declare class ValidateRule {
    validator: string;
    condition: string;
    errorCode: string;
    message: string;
    constructor(init?: Partial<ValidateRule>);
}
export declare class ValidationRule extends ValidateRule {
    id: number;
    type: string;
    field: string;
    createdBy: string;
    createdDate?: string;
    modifiedBy: string;
    modifiedDate?: string;
    suspendedBy: string;
    suspendedDate?: string;
    notes: string;
    constructor(init?: Partial<ValidationRule>);
}
export declare class AdminUserBase {
    userName: string;
    firstName: string;
    lastName: string;
    displayName: string;
    email: string;
    password: string;
    profileUrl: string;
    userAuthProperties: {
        [index: string]: string;
    };
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AdminUserBase>);
}
export declare class QueryBase {
    skip?: number;
    take?: number;
    orderBy: string;
    orderByDesc: string;
    include: string;
    fields: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<QueryBase>);
}
export declare class QueryDb<T> extends QueryBase {
    constructor(init?: Partial<QueryDb<T>>);
}
export declare class CrudEvent {
    id: number;
    eventType: string;
    model: string;
    modelId: string;
    eventDate: string;
    rowsUpdated?: number;
    requestType: string;
    requestBody: string;
    userAuthId: string;
    userAuthName: string;
    remoteIp: string;
    urn: string;
    refId?: number;
    refIdStr: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<CrudEvent>);
}
export declare class RedisEndpointInfo {
    host: string;
    port: number;
    ssl?: boolean;
    db: number;
    username: string;
    password: string;
    constructor(init?: Partial<RedisEndpointInfo>);
}
export declare class AppInfo {
    baseUrl: string;
    serviceStackVersion: string;
    serviceName: string;
    serviceDescription: string;
    serviceIconUrl: string;
    brandUrl: string;
    brandImageUrl: string;
    textColor: string;
    linkColor: string;
    backgroundColor: string;
    backgroundImageUrl: string;
    iconUrl: string;
    jsTextCase: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AppInfo>);
}
export declare class ImageInfo {
    svg: string;
    uri: string;
    alt: string;
    cls: string;
    constructor(init?: Partial<ImageInfo>);
}
export declare class LinkInfo {
    id: string;
    href: string;
    label: string;
    icon: ImageInfo;
    show: string;
    hide: string;
    constructor(init?: Partial<LinkInfo>);
}
export declare class ThemeInfo {
    form: string;
    modelIcon: ImageInfo;
    constructor(init?: Partial<ThemeInfo>);
}
export declare class ApiCss {
    form: string;
    fieldset: string;
    field: string;
    constructor(init?: Partial<ApiCss>);
}
export declare class AppTags {
    default: string;
    other: string;
    constructor(init?: Partial<AppTags>);
}
export declare class LocodeUi {
    css: ApiCss;
    tags: AppTags;
    maxFieldLength: number;
    maxNestedFields: number;
    maxNestedFieldLength: number;
    constructor(init?: Partial<LocodeUi>);
}
export declare class ExplorerUi {
    css: ApiCss;
    tags: AppTags;
    constructor(init?: Partial<ExplorerUi>);
}
export declare class AdminUi {
    css: ApiCss;
    constructor(init?: Partial<AdminUi>);
}
export declare class FormatInfo {
    method: string;
    options: string;
    locale: string;
    constructor(init?: Partial<FormatInfo>);
}
export declare class ApiFormat {
    locale: string;
    assumeUtc: boolean;
    number: FormatInfo;
    date: FormatInfo;
    constructor(init?: Partial<ApiFormat>);
}
export declare class UiInfo {
    brandIcon: ImageInfo;
    hideTags: string[];
    modules: string[];
    alwaysHideTags: string[];
    adminLinks: LinkInfo[];
    theme: ThemeInfo;
    locode: LocodeUi;
    explorer: ExplorerUi;
    admin: AdminUi;
    defaultFormats: ApiFormat;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<UiInfo>);
}
export declare class ConfigInfo {
    debugMode?: boolean;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ConfigInfo>);
}
export declare class NavItem {
    label: string;
    href: string;
    exact?: boolean;
    id: string;
    className: string;
    iconClass: string;
    iconSrc: string;
    show: string;
    hide: string;
    children: NavItem[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<NavItem>);
}
export declare class FieldCss {
    field: string;
    input: string;
    label: string;
    constructor(init?: Partial<FieldCss>);
}
export declare class InputInfo {
    id: string;
    name: string;
    type: string;
    value: string;
    placeholder: string;
    help: string;
    label: string;
    title: string;
    size: string;
    pattern: string;
    readOnly?: boolean;
    required?: boolean;
    disabled?: boolean;
    autocomplete: string;
    autofocus: string;
    min: string;
    max: string;
    step?: number;
    minLength?: number;
    maxLength?: number;
    accept: string;
    capture: string;
    multiple?: boolean;
    allowableValues: string[];
    allowableEntries: KeyValuePair<String, String>[];
    options: string;
    ignore?: boolean;
    css: FieldCss;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<InputInfo>);
}
export declare class MetaAuthProvider {
    name: string;
    label: string;
    type: string;
    navItem: NavItem;
    icon: ImageInfo;
    formLayout: InputInfo[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<MetaAuthProvider>);
}
export declare class AuthInfo {
    hasAuthSecret?: boolean;
    hasAuthRepository?: boolean;
    includesRoles?: boolean;
    includesOAuthTokens?: boolean;
    htmlRedirect: string;
    authProviders: MetaAuthProvider[];
    roleLinks: {
        [index: string]: LinkInfo[];
    };
    serviceRoutes: {
        [index: string]: string[];
    };
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AuthInfo>);
}
export declare class AutoQueryConvention {
    name: string;
    value: string;
    types: string;
    valueType: string;
    constructor(init?: Partial<AutoQueryConvention>);
}
export declare class AutoQueryInfo {
    maxLimit?: number;
    untypedQueries?: boolean;
    rawSqlFilters?: boolean;
    autoQueryViewer?: boolean;
    async?: boolean;
    orderByPrimaryKey?: boolean;
    crudEvents?: boolean;
    crudEventsServices?: boolean;
    accessRole: string;
    namedConnection: string;
    viewerConventions: AutoQueryConvention[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AutoQueryInfo>);
}
export declare class ScriptMethodType {
    name: string;
    paramNames: string[];
    paramTypes: string[];
    returnType: string;
    constructor(init?: Partial<ScriptMethodType>);
}
export declare class ValidationInfo {
    hasValidationSource?: boolean;
    hasValidationSourceAdmin?: boolean;
    serviceRoutes: {
        [index: string]: string[];
    };
    typeValidators: ScriptMethodType[];
    propertyValidators: ScriptMethodType[];
    accessRole: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ValidationInfo>);
}
export declare class SharpPagesInfo {
    apiPath: string;
    scriptAdminRole: string;
    metadataDebugAdminRole: string;
    metadataDebug?: boolean;
    spaFallback?: boolean;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<SharpPagesInfo>);
}
export declare class RequestLogsInfo {
    accessRole: string;
    requiredRoles: string[];
    requestLogger: string;
    defaultLimit: number;
    serviceRoutes: {
        [index: string]: string[];
    };
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<RequestLogsInfo>);
}
export declare class ProfilingInfo {
    accessRole: string;
    defaultLimit: number;
    summaryFields: string[];
    tagLabel: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ProfilingInfo>);
}
export declare class FilesUploadLocation {
    name: string;
    readAccessRole: string;
    writeAccessRole: string;
    allowExtensions: string[];
    allowOperations: string;
    maxFileCount?: number;
    minFileBytes?: number;
    maxFileBytes?: number;
    constructor(init?: Partial<FilesUploadLocation>);
}
export declare class FilesUploadInfo {
    basePath: string;
    locations: FilesUploadLocation[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<FilesUploadInfo>);
}
export declare class MetadataTypeName {
    name: string;
    namespace: string;
    genericArgs: string[];
    constructor(init?: Partial<MetadataTypeName>);
}
export declare class MetadataDataContract {
    name: string;
    namespace: string;
    constructor(init?: Partial<MetadataDataContract>);
}
export declare class MetadataDataMember {
    name: string;
    order?: number;
    isRequired?: boolean;
    emitDefaultValue?: boolean;
    constructor(init?: Partial<MetadataDataMember>);
}
export declare class MetadataAttribute {
    name: string;
    constructorArgs: MetadataPropertyType[];
    args: MetadataPropertyType[];
    constructor(init?: Partial<MetadataAttribute>);
}
export declare class RefInfo {
    model: string;
    selfId: string;
    refId: string;
    refLabel: string;
    constructor(init?: Partial<RefInfo>);
}
export declare class MetadataPropertyType {
    name: string;
    type: string;
    namespace: string;
    isValueType?: boolean;
    isEnum?: boolean;
    isPrimaryKey?: boolean;
    genericArgs: string[];
    value: string;
    description: string;
    dataMember: MetadataDataMember;
    readOnly?: boolean;
    paramType: string;
    displayType: string;
    isRequired?: boolean;
    allowableValues: string[];
    allowableMin?: number;
    allowableMax?: number;
    attributes: MetadataAttribute[];
    input: InputInfo;
    format: FormatInfo;
    ref: RefInfo;
    constructor(init?: Partial<MetadataPropertyType>);
}
export declare class MetadataType {
    name: string;
    namespace: string;
    genericArgs: string[];
    inherits: MetadataTypeName;
    implements: MetadataTypeName[];
    displayType: string;
    description: string;
    notes: string;
    icon: ImageInfo;
    isNested?: boolean;
    isEnum?: boolean;
    isEnumInt?: boolean;
    isInterface?: boolean;
    isAbstract?: boolean;
    dataContract: MetadataDataContract;
    properties: MetadataPropertyType[];
    attributes: MetadataAttribute[];
    innerTypes: MetadataTypeName[];
    enumNames: string[];
    enumValues: string[];
    enumMemberValues: string[];
    enumDescriptions: string[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<MetadataType>);
}
export declare class MediaRule {
    size: string;
    rule: string;
    applyTo: string[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<MediaRule>);
}
export declare class AdminUsersInfo {
    accessRole: string;
    enabled: string[];
    userAuth: MetadataType;
    allRoles: string[];
    allPermissions: string[];
    queryUserAuthProperties: string[];
    queryMediaRules: MediaRule[];
    formLayout: InputInfo[];
    css: ApiCss;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AdminUsersInfo>);
}
export declare class AdminRedisInfo {
    queryLimit: number;
    databases: number[];
    modifiableConnection?: boolean;
    endpoint: RedisEndpointInfo;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AdminRedisInfo>);
}
export declare class SchemaInfo {
    alias: string;
    name: string;
    tables: string[];
    constructor(init?: Partial<SchemaInfo>);
}
export declare class DatabaseInfo {
    alias: string;
    name: string;
    schemas: SchemaInfo[];
    constructor(init?: Partial<DatabaseInfo>);
}
export declare class AdminDatabaseInfo {
    queryLimit: number;
    databases: DatabaseInfo[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AdminDatabaseInfo>);
}
export declare class PluginInfo {
    loaded: string[];
    auth: AuthInfo;
    autoQuery: AutoQueryInfo;
    validation: ValidationInfo;
    sharpPages: SharpPagesInfo;
    requestLogs: RequestLogsInfo;
    profiling: ProfilingInfo;
    filesUpload: FilesUploadInfo;
    adminUsers: AdminUsersInfo;
    adminRedis: AdminRedisInfo;
    adminDatabase: AdminDatabaseInfo;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<PluginInfo>);
}
export declare class CustomPluginInfo {
    accessRole: string;
    serviceRoutes: {
        [index: string]: string[];
    };
    enabled: string[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<CustomPluginInfo>);
}
export declare class MetadataTypesConfig {
    baseUrl: string;
    usePath: string;
    makePartial: boolean;
    makeVirtual: boolean;
    makeInternal: boolean;
    baseClass: string;
    package: string;
    addReturnMarker: boolean;
    addDescriptionAsComments: boolean;
    addDataContractAttributes: boolean;
    addIndexesToDataMembers: boolean;
    addGeneratedCodeAttributes: boolean;
    addImplicitVersion?: number;
    addResponseStatus: boolean;
    addServiceStackTypes: boolean;
    addModelExtensions: boolean;
    addPropertyAccessors: boolean;
    excludeGenericBaseTypes: boolean;
    settersReturnThis: boolean;
    makePropertiesOptional: boolean;
    exportAsTypes: boolean;
    excludeImplementedInterfaces: boolean;
    addDefaultXmlNamespace: string;
    makeDataContractsExtensible: boolean;
    initializeCollections: boolean;
    addNamespaces: string[];
    defaultNamespaces: string[];
    defaultImports: string[];
    includeTypes: string[];
    excludeTypes: string[];
    exportTags: string[];
    treatTypesAsStrings: string[];
    exportValueTypes: boolean;
    globalNamespace: string;
    excludeNamespace: boolean;
    dataClass: string;
    dataClassJson: string;
    ignoreTypes: string[];
    exportTypes: string[];
    exportAttributes: string[];
    ignoreTypesInNamespaces: string[];
    constructor(init?: Partial<MetadataTypesConfig>);
}
export declare class MetadataRoute {
    path: string;
    verbs: string;
    notes: string;
    summary: string;
    constructor(init?: Partial<MetadataRoute>);
}
export declare class ApiUiInfo {
    locodeCss: ApiCss;
    explorerCss: ApiCss;
    formLayout: InputInfo[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ApiUiInfo>);
}
export declare class MetadataOperationType {
    request: MetadataType;
    response: MetadataType;
    actions: string[];
    returnsVoid?: boolean;
    method: string;
    returnType: MetadataTypeName;
    routes: MetadataRoute[];
    dataModel: MetadataTypeName;
    viewModel: MetadataTypeName;
    requiresAuth?: boolean;
    requiredRoles: string[];
    requiresAnyRole: string[];
    requiredPermissions: string[];
    requiresAnyPermission: string[];
    tags: string[];
    ui: ApiUiInfo;
    constructor(init?: Partial<MetadataOperationType>);
}
export declare class MetadataTypes {
    config: MetadataTypesConfig;
    namespaces: string[];
    types: MetadataType[];
    operations: MetadataOperationType[];
    constructor(init?: Partial<MetadataTypes>);
}
export declare class ServerStats {
    redis: {
        [index: string]: number;
    };
    serverEvents: {
        [index: string]: string;
    };
    mqDescription: string;
    mqWorkers: {
        [index: string]: number;
    };
    constructor(init?: Partial<ServerStats>);
}
export declare class ResponseError {
    errorCode: string;
    fieldName: string;
    message: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ResponseError>);
}
export declare class ResponseStatus {
    errorCode: string;
    message: string;
    stackTrace: string;
    errors: ResponseError[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<ResponseStatus>);
}
export declare class RequestLogEntry {
    id: number;
    traceId: string;
    operationName: string;
    dateTime: string;
    statusCode: number;
    statusDescription: string;
    httpMethod: string;
    absoluteUri: string;
    pathInfo: string;
    requestBody: string;
    requestDto: Object;
    userAuthId: string;
    sessionId: string;
    ipAddress: string;
    forwardedFor: string;
    referer: string;
    headers: {
        [index: string]: string;
    };
    formData: {
        [index: string]: string;
    };
    items: {
        [index: string]: string;
    };
    responseHeaders: {
        [index: string]: string;
    };
    session: Object;
    responseDto: Object;
    errorResponse: Object;
    exceptionSource: string;
    exceptionData: any;
    requestDuration: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<RequestLogEntry>);
}
export declare class DiagnosticEntry {
    id: number;
    traceId: string;
    source: string;
    eventType: string;
    message: string;
    operation: string;
    threadId: number;
    error: ResponseStatus;
    commandType: string;
    command: string;
    userAuthId: string;
    sessionId: string;
    arg: string;
    args: string[];
    argLengths: number[];
    namedArgs: {
        [index: string]: Object;
    };
    duration?: string;
    timestamp: number;
    date: string;
    tag: string;
    stackTrace: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<DiagnosticEntry>);
}
export declare class RedisSearchResult {
    id: string;
    type: string;
    ttl: number;
    size: number;
    constructor(init?: Partial<RedisSearchResult>);
}
export declare class RedisText {
    text: string;
    children: RedisText[];
    constructor(init?: Partial<RedisText>);
}
export declare class KeyValuePair<TKey, TValue> {
    key: TKey;
    value: TValue;
    constructor(init?: Partial<KeyValuePair<TKey, TValue>>);
}
export declare class AppMetadata {
    app: AppInfo;
    ui: UiInfo;
    config: ConfigInfo;
    contentTypeFormats: {
        [index: string]: string;
    };
    httpHandlers: {
        [index: string]: string;
    };
    plugins: PluginInfo;
    customPlugins: {
        [index: string]: CustomPluginInfo;
    };
    api: MetadataTypes;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AppMetadata>);
}
export declare class AdminDashboardResponse {
    serverStats: ServerStats;
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminDashboardResponse>);
}
export declare class GetValidationRulesResponse {
    results: ValidationRule[];
    responseStatus: ResponseStatus;
    constructor(init?: Partial<GetValidationRulesResponse>);
}
export declare class AuthenticateResponse implements IHasSessionId, IHasBearerToken {
    userId: string;
    sessionId: string;
    userName: string;
    displayName: string;
    referrerUrl: string;
    bearerToken: string;
    refreshToken: string;
    profileUrl: string;
    roles: string[];
    permissions: string[];
    responseStatus: ResponseStatus;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AuthenticateResponse>);
}
export declare class AssignRolesResponse {
    allRoles: string[];
    allPermissions: string[];
    meta: {
        [index: string]: string;
    };
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AssignRolesResponse>);
}
export declare class UnAssignRolesResponse {
    allRoles: string[];
    allPermissions: string[];
    meta: {
        [index: string]: string;
    };
    responseStatus: ResponseStatus;
    constructor(init?: Partial<UnAssignRolesResponse>);
}
export declare class AdminUserResponse {
    id: string;
    result: {
        [index: string]: Object;
    };
    details: {
        [index: string]: Object;
    }[];
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminUserResponse>);
}
export declare class AdminUsersResponse {
    results: {
        [index: string]: Object;
    }[];
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminUsersResponse>);
}
export declare class AdminDeleteUserResponse {
    id: string;
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminDeleteUserResponse>);
}
export declare class QueryResponse<CrudEvent> {
    offset: number;
    total: number;
    results: CrudEvent[];
    meta: {
        [index: string]: string;
    };
    responseStatus: ResponseStatus;
    constructor(init?: Partial<QueryResponse<CrudEvent>>);
}
export declare class RequestLogsResponse {
    results: RequestLogEntry[];
    usage: {
        [index: string]: string;
    };
    total: number;
    responseStatus: ResponseStatus;
    constructor(init?: Partial<RequestLogsResponse>);
}
export declare class AdminProfilingResponse {
    results: DiagnosticEntry[];
    total: number;
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminProfilingResponse>);
}
export declare class AdminRedisResponse {
    db: number;
    searchResults: RedisSearchResult[];
    info: {
        [index: string]: string;
    };
    endpoint: RedisEndpointInfo;
    result: RedisText;
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminRedisResponse>);
}
export declare class AdminDatabaseResponse {
    results: {
        [index: string]: Object;
    }[];
    total?: number;
    columns: MetadataPropertyType[];
    responseStatus: ResponseStatus;
    constructor(init?: Partial<AdminDatabaseResponse>);
}
export declare class MetadataApp implements IReturn<AppMetadata>, IGet {
    view: string;
    includeTypes: string[];
    constructor(init?: Partial<MetadataApp>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AppMetadata;
}
export declare class AdminDashboard implements IReturn<AdminDashboardResponse> {
    constructor(init?: Partial<AdminDashboard>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminDashboardResponse;
}
export declare class GetValidationRules implements IReturn<GetValidationRulesResponse> {
    authSecret: string;
    type: string;
    constructor(init?: Partial<GetValidationRules>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): GetValidationRulesResponse;
}
export declare class ModifyValidationRules implements IReturnVoid {
    authSecret: string;
    saveRules: ValidationRule[];
    deleteRuleIds: number[];
    suspendRuleIds: number[];
    unsuspendRuleIds: number[];
    clearCache?: boolean;
    constructor(init?: Partial<ModifyValidationRules>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): void;
}
/**
* Sign In
*/
export declare class Authenticate implements IReturn<AuthenticateResponse>, IPost {
    /**
    * AuthProvider, e.g. credentials
    */
    provider: string;
    state: string;
    oauth_token: string;
    oauth_verifier: string;
    userName: string;
    password: string;
    rememberMe?: boolean;
    errorView: string;
    nonce: string;
    uri: string;
    response: string;
    qop: string;
    nc: string;
    cnonce: string;
    accessToken: string;
    accessTokenSecret: string;
    scope: string;
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<Authenticate>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AuthenticateResponse;
}
export declare class AssignRoles implements IReturn<AssignRolesResponse>, IPost {
    userName: string;
    permissions: string[];
    roles: string[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<AssignRoles>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AssignRolesResponse;
}
export declare class UnAssignRoles implements IReturn<UnAssignRolesResponse>, IPost {
    userName: string;
    permissions: string[];
    roles: string[];
    meta: {
        [index: string]: string;
    };
    constructor(init?: Partial<UnAssignRoles>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): UnAssignRolesResponse;
}
export declare class AdminGetUser implements IReturn<AdminUserResponse>, IGet {
    id: string;
    constructor(init?: Partial<AdminGetUser>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminUserResponse;
}
export declare class AdminQueryUsers implements IReturn<AdminUsersResponse>, IGet {
    query: string;
    orderBy: string;
    skip?: number;
    take?: number;
    constructor(init?: Partial<AdminQueryUsers>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminUsersResponse;
}
export declare class AdminCreateUser extends AdminUserBase implements IReturn<AdminUserResponse>, IPost {
    roles: string[];
    permissions: string[];
    constructor(init?: Partial<AdminCreateUser>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminUserResponse;
}
export declare class AdminUpdateUser extends AdminUserBase implements IReturn<AdminUserResponse>, IPut {
    id: string;
    lockUser?: boolean;
    unlockUser?: boolean;
    addRoles: string[];
    removeRoles: string[];
    addPermissions: string[];
    removePermissions: string[];
    constructor(init?: Partial<AdminUpdateUser>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminUserResponse;
}
export declare class AdminDeleteUser implements IReturn<AdminDeleteUserResponse>, IDelete {
    id: string;
    constructor(init?: Partial<AdminDeleteUser>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminDeleteUserResponse;
}
export declare class GetCrudEvents extends QueryDb<CrudEvent> implements IReturn<QueryResponse<CrudEvent>> {
    authSecret: string;
    model: string;
    modelId: string;
    constructor(init?: Partial<GetCrudEvents>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): QueryResponse<CrudEvent>;
}
export declare class RequestLogs implements IReturn<RequestLogsResponse> {
    beforeSecs?: number;
    afterSecs?: number;
    operationName: string;
    ipAddress: string;
    forwardedFor: string;
    userAuthId: string;
    sessionId: string;
    referer: string;
    pathInfo: string;
    ids: number[];
    beforeId?: number;
    afterId?: number;
    hasResponse?: boolean;
    withErrors?: boolean;
    enableSessionTracking?: boolean;
    enableResponseTracking?: boolean;
    enableErrorTracking?: boolean;
    durationLongerThan?: string;
    durationLessThan?: string;
    skip: number;
    take?: number;
    orderBy: string;
    constructor(init?: Partial<RequestLogs>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): RequestLogsResponse;
}
export declare class AdminProfiling implements IReturn<AdminProfilingResponse> {
    source: string;
    eventType: string;
    threadId?: number;
    traceId: string;
    userAuthId: string;
    sessionId: string;
    tag: string;
    skip: number;
    take?: number;
    orderBy: string;
    withErrors?: boolean;
    pending?: boolean;
    constructor(init?: Partial<AdminProfiling>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminProfilingResponse;
}
export declare class AdminRedis implements IReturn<AdminRedisResponse>, IPost {
    db?: number;
    query: string;
    reconnect: RedisEndpointInfo;
    take?: number;
    position?: number;
    args: string[];
    constructor(init?: Partial<AdminRedis>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminRedisResponse;
}
export declare class AdminDatabase implements IReturn<AdminDatabaseResponse>, IGet {
    db: string;
    schema: string;
    table: string;
    fields: string[];
    take?: number;
    skip?: number;
    orderBy: string;
    include: string;
    constructor(init?: Partial<AdminDatabase>);
    getTypeName(): string;
    getMethod(): string;
    createResponse(): AdminDatabaseResponse;
}
/**
 * Server Metadata containing App capabilities and APIs used to dynamically render the UI
 */
export declare let Server: AppMetadata;
/** Tailwind Responsive Breakpoints
 * { 2xl:1536, xl:1280, lg:1024, md:768, sm:640 } */
export declare type Breakpoints = Record<'2xl' | 'xl' | 'lg' | 'md' | 'sm', boolean>;
/** Return self or reactive proxy of self */
export declare type Identity = <T>(args: T) => T;
/** Invoke a Tailwind Definition Rule */
export declare type Transition = (prop: string, enter: boolean) => boolean;
/** Publish/Subscribe to App Events */
export declare type Bus = {
    subscribe: (type: string, callback: Function) => {
        unsubscribe: () => void;
    };
    publish: (eventType: string, arg: any) => void;
};
/** High-level API encapsulating client PetiteVue App */
export declare type App = {
    /** Publish/Subscript to App events */
    events: Bus;
    /** PetiteVue App instance */
    readonly petite: any;
    /** Register map of PetiteVue components using key as Components Name */
    components: (components: Record<string, Function | Object>) => void;
    /** Register single component
     * @param {string} name
     * @param {string|Function} component Auto Component template HTML or Component Function */
    component: (name: string, component: string | Function) => void;
    /** Register Auto Component with $template contents
     * @param {string} name
     * @param {string} $template */
    template: (name: string, $template: string) => void;
    /** Register map of Auto Components using key as Components Name */
    templates: (templates: Record<string, string>) => void;
    /** Register PetiteVue directive */
    directive: (name: string, fn: Function) => void;
    /** Register (non-reactive) global App state property */
    prop: (name: string, val: any) => void;
    /** Register multiple (non-reactive) global App state props */
    props: (props: Record<string, any>) => void;
    /** Build PetiteVue App instance */
    build: (args: Record<string, any>) => any;
    /** Dynamically load external script src */
    import: (arg0: string) => Promise<any>;
    /** Register callback to invoke after App has started */
    onStart: (f: Function) => void;
    /** Start App instance */
    start: () => void;
    /** App function for unsubscribing 'sub' subscription in Component instance */
    unsubscribe: () => void;
    /** PetiteVue.createApp - create PetiteVue instance */
    createApp: (args: any) => any;
    /** PetiteVue.nextTick - register callback to be fired afterA next async loop */
    nextTick: (f: Function) => void;
    /** PetiteVue.reactive - create a reactive store */
    reactive: Identity;
};
/** Utility class for managing Forms UI and behavior */
export declare type Forms = {
    /** Server Metadata */
    Server: AppMetadata;
    /** Client Metadata APIs */
    Meta: Meta;
    getId: (type: MetadataType, row: any) => any;
    getType: (typeRef: string | {
        namespace: string;
        name: string;
    }) => MetadataType;
    inputId: (input: {
        id: string;
    }) => string;
    colClass: (fields: number) => string;
    inputProp: (prop: MetadataPropertyType) => {
        id: string;
        type: string;
        'data-type': string;
    };
    getPrimaryKey: (type: MetadataType) => MetadataPropertyType | null;
    typeProperties: (type: MetadataType) => MetadataPropertyType[];
    relativeTime: (val: string | number | Date, rtf?: Intl.RelativeTimeFormat) => string;
    relativeTimeFromMs: (elapsedMs: number, rtf?: Intl.RelativeTimeFormat) => string;
    relativeTimeFromDate: (d: Date, from?: Date) => string;
    Lookup: {};
    lookupLabel: (model: any, id: any, label: string) => any;
    refInfo: (row: any, prop: MetadataPropertyType, props: MetadataPropertyType[]) => {
        href: {
            op: string;
            skip: any;
            edit: any;
            new: any;
            $qs: {
                [x: string]: any;
            };
        };
        icon: any;
        html: any;
    };
    fetchLookupValues: (results: any[], props: MetadataPropertyType[], refreshFn: () => void) => void;
    theme: ThemeInfo;
    formClass: string;
    gridClass: string;
    opTitle(op: MetadataOperationType): string;
    forAutoForm(type: MetadataType): (field: any) => void;
    forCreate(type: MetadataType): (field: any) => void;
    forEdit(type: MetadataType): (field: any) => void;
    getFormProp(id: any, type: any): MetadataPropertyType;
    getGridInputs(formLayout: InputInfo[], f?: (args: {
        id: string;
        input: InputInfo;
        rowClass: string;
    }) => void): {
        id: string;
        input: InputInfo;
        rowClass: string;
    }[];
    getGridInput(input: InputInfo, f?: (args: {
        id: string;
        input: InputInfo;
        rowClass: string;
    }) => void): {
        id: string;
        input: InputInfo;
        rowClass: string;
    };
    getFieldError(error: any, id: any): string | null;
    kvpValues(input: any): {
        key: any;
        value: any;
    }[];
    useLabel(input: any): string | null;
    usePlaceholder(input: any): string | null;
    isRequired(input: any): boolean;
    resolveFormLayout(op: MetadataOperationType): InputInfo[];
    formValues(form: any): Record<string, any>;
    groupTypes(allTypes: any): any[];
    complexProp(prop: any): boolean;
    supportsProp(prop: any): boolean;
    populateModel(model: any, formLayout: any): Record<string, any>;
    apiValue(o: any): any;
    format(o: any, prop: MetadataPropertyType): any;
};
/** Generic functionality around AppMetadata */
export declare type Meta = {
    /** Global Cache */
    CACHE: {};
    /** HTTP Errors specially handled by Locode */
    HttpErrors: Record<number, string>;
    /** Server Metadata */
    Server: AppMetadata;
    /** Map of Request DTO names to `MetadataOperationType` */
    OpsMap: Record<string, MetadataOperationType>;
    /** Map of DTO names to `MetadataType` */
    TypesMap: Record<string, MetadataType>;
    /** Map of DTO namespace + names to `MetadataType` */
    FullTypesMap: Record<string, MetadataType>;
    /** Get list of Request DTOs */
    operations: MetadataOperationType[];
    /** Get list of unique API tags */
    tags: string[];
    /** Find `MetadataOperationType` by API name */
    getOp: (opName: string) => MetadataOperationType;
    /** Find `MetadataType` by DTO name */
    getType: (typeRef: ({
        namespace?: string;
        name: string;
    } | string)) => null | MetadataType;
    /** Check whether a Type is an Enum */
    isEnum: (type: string) => boolean;
    /** Get Enum Values of an Enum Type */
    enumValues: (type: string) => {
        key: string;
        value: string;
    }[];
    /** Get API Icon */
    getIcon: (args: ({
        op?: MetadataOperationType;
        type?: MetadataType;
    })) => {
        svg: string;
    };
    /** Get Locode URL */
    locodeUrl: (op: string) => string;
    /** Get URL with initial queryString state */
    urlWithState: (url: string) => string;
};
/** Reactive store to manage page navigation state and sync with history.pushState */
export declare type Routes = {
    /** The arg name that's used to identify the page name */
    page: string;
    /** Populate Route state */
    set: (args: Record<string, any>) => void;
    /** Snapshot of the current route state */
    state: Record<string, any>;
    /** Navigate to new route state */
    to: (args: Record<string, any>) => void;
    /** Return URL of current route state */
    href: (args: Record<string, any>) => string;
};
/** APIs for resolving SVG icons and data URIs for different File Types */
interface Files {
    /** Get Icon SVG for .ext */
    extSvg(ext: string): string | null;
    /** Get Icon src for .ext */
    extSrc(ext: string): string | null;
    /** Return file extension (without '.; prefix) of path or URI */
    getExt(path: string): string | null;
    /** Encode SVG for embedding in Data URI */
    encodeSvg(s: string): string;
    /** Return whether path is a URI to a previewable image */
    canPreview(path: string): boolean;
    /** Return file name part of URI or file path */
    getFileName(path: string): string | null;
    /** Format bytes into human-readable file size */
    formatBytes(bytes: number, d?: number): string;
    /** Get the Icon src for a file path or URI, previewable resources will return self, otherwise returns SVG URI of .ext */
    filePathUri(path: string): string | null;
    /** Convert SVG to Data URI */
    svgToDataUri(svg: string): string;
    /** Return Image URI of INPUT file attachments */
    fileImageUri(file: File | MediaSource): string;
    /** Clear all remaining Image URIs of INPUT file attachments */
    flush(): void;
}
export declare let Files: Files;
/** APIs to inspect .NET Types */
interface Types {
    /** Return well-known C# alias for its .NET Type name */
    alias(type: string): any;
    /** Return underlying Type if nullable */
    unwrap(type: string): string;
    /** Resolve well-known C# Type Name from Type Ref */
    typeName(metaType: {
        name: string;
        genericArgs: string[];
    }): string;
    /** Resolve well-known C# Type Name from Name and Generic Args */
    typeName2(name: string, genericArgs: string[]): string;
    /** Return true if .NET Type is numeric */
    isNumber(type: string): boolean;
    /** Return true if .NET Type is a string */
    isString(type: string): boolean;
    /** Return true if .NET Type is a collection */
    isArray(type: string): boolean;
    /** Return true if typeof is a scalar value (string|number|symbol|boolean) */
    isPrimitive(type: string): boolean;
    /** Return value suitable for human display */
    formatValue(type: string, value: any): any;
    /** Create a unique key string from a Type Ref */
    key(typeRef: {
        namespace: string;
        name: string;
    }): string | null;
    /** Return true if both Type Refs are equivalent */
    equals(a: {
        namespace: string;
        name: string;
    }, b: {
        namespace: string;
        name: string;
    }): boolean;
    /** Return true if Property has named Attribute */
    propHasAttr(p: MetadataPropertyType, attr: string): boolean;
    /** Return named property on Type (case-insensitive) */
    getProp(type: MetadataType, name: string): MetadataPropertyType;
    /** Return all properties of a Type, inc. base class properties  */
    typeProperties(TypesMap: any, type: any): MetadataPropertyType[];
}
export declare let Types: Types;
/** Custom route params used in API Explorer */
export declare type ExplorerRoutes = {
    op?: string;
    tab?: string;
    lang?: string;
    provider?: string;
    preview?: string;
    body?: string;
    doc?: string;
    detailSrc?: string;
    form?: string;
    response?: string;
};
/** Route methods used in API Explorer */
export declare type ExplorerRoutesExtend = {
    queryHref(): string;
};
/** App's primary reactive store maintaining global functionality for Admin UI */
export declare type ExplorerStore = {
    cachedFetch: (url: string) => Promise<string>;
    copied: boolean;
    readonly opTabs: {
        [p: string]: string;
    };
    sideNav: {
        expanded: boolean;
        operations: MetadataOperationType[];
        tag: string;
    }[];
    auth: AuthenticateResponse;
    readonly displayName: string | null;
    loadLang: () => void;
    langCache: () => {
        op: string;
        lang: string;
        url: string;
    };
    login: (args: any, $on?: Function) => void;
    detailSrcResult: {};
    logout: () => void;
    readonly isServiceStackType: boolean;
    api: ApiResult<AuthenticateResponse>;
    init: () => void;
    readonly op: MetadataOperationType | null;
    debug: boolean;
    readonly filteredSideNav: {
        tag: string;
        operations: MetadataOperationType[];
        expanded: boolean;
    }[];
    readonly authProfileUrl: string | null;
    previewResult: string | null;
    readonly activeLangSrc: string | null;
    readonly previewCache: {
        preview: string;
        url: string;
        lang: string;
    } | null;
    toggle: (tag: string) => void;
    getTypeUrl: (types: string) => string;
    readonly authRoles: string[];
    filter: string;
    loadDetailSrc: () => void;
    baseUrl: string;
    readonly activeDetailSrc: string;
    readonly authLinks: LinkInfo[];
    readonly opName: string;
    readonly previewSrc: string;
    SignIn: (opt: any) => Function;
    hasRole: (role: string) => boolean;
    loadPreview: () => void;
    readonly authPermissions: string[];
    readonly useLang: string;
    invalidAccess: () => string | null;
};
/** Method arguments of custom Doc Components */
export interface DocComponentArgs {
    store: ExplorerStore;
    routes: ExplorerRoutes & Routes;
    breakpoints: Breakpoints;
    op: () => MetadataOperationType;
}
/** Method Signature of custom Doc Components */
export declare type DocComponent = (args: DocComponentArgs) => Record<string, any>;
/** Custom route params used in Locode */
export declare type LocodeRoutes = {
    op?: string;
    tab?: string;
    provider?: string;
    preview?: string;
    body?: string;
    doc?: string;
    skip?: string;
    new?: string;
    edit?: string;
};
/** Route methods used in Locode */
export declare type LocodeRoutesExtend = {
    onEditChange(any: any): void;
    update(): void;
    uiHref(any: any): string;
};
export declare type LocodeStore = {
    cachedFetch: (url: string) => Promise<string>;
    copied: boolean;
    sideNav: {
        expanded: boolean;
        operations: MetadataOperationType[];
        tag: string;
    }[];
    auth: AuthenticateResponse;
    readonly displayName: string | null;
    login: (args: any, $on?: Function) => void;
    detailSrcResult: any;
    logout: () => void;
    readonly isServiceStackType: boolean;
    readonly opViewModel: string;
    api: ApiResult<AuthenticateResponse>;
    modalLookup: any | null;
    init: () => void;
    readonly op: MetadataOperationType;
    debug: boolean;
    readonly filteredSideNav: {
        tag: string;
        operations: MetadataOperationType[];
        expanded: boolean;
    }[];
    readonly authProfileUrl: string | null;
    previewResult: string | null;
    readonly opDesc: string;
    toggle: (tag: string) => void;
    readonly opDataModel: string;
    readonly authRoles: string[];
    filter: string;
    baseUrl: string;
    readonly authLinks: LinkInfo[];
    readonly opName: string;
    SignIn: (opt: any) => Function;
    hasRole: (role: string) => boolean;
    readonly authPermissions: string[];
    readonly useLang: string;
    invalidAccess: () => string | null;
};
/** Manage users query & filter preferences in the Users browsers localStorage */
export declare type LocodeSettings = {
    op: (op: string) => any;
    lookup: (op: string) => any;
    saveOp: (op: string, fn: Function) => void;
    hasPrefs: (op: string) => boolean;
    saveOpProp: (op: string, name: string, fn: Function) => void;
    saveLookup: (op: string, fn: Function) => void;
    events: {
        op: (op: string) => string;
        lookup: (op: string) => string;
        opProp: (op: string, name: string) => string;
    };
    opProp: (op: string, name: string) => any;
    clearPrefs: (op: string) => void;
};
/** Create a new state for an API that encapsulates its invocation and execution */
export declare type ApiState = {
    op: MetadataOperationType;
    client: any;
    apiState: ApiState;
    formLayout: any;
    createModel: (args: any) => any;
    apiLoading: boolean;
    apiResult: any;
    readonly api: any;
    createRequest: (args: any) => any;
    model: any;
    title: string | null;
    readonly error: ResponseStatus;
    readonly errorSummary: string | null;
    fieldError(id: string): string | null;
    field(propName: string, f?: (args: {
        id: string;
        input: InputInfo;
        rowClass: string;
    }) => void): any;
    apiSend(dtoArgs: Record<string, any>, queryArgs?: Record<string, any>): any;
    apiForm(formData: FormData, queryArgs?: Record<string, any>): any;
};
/** All CRUD API States available for this operation */
export declare type CrudApisState = {
    opQuery: MetadataOperationType | null;
    opCreate: MetadataOperationType | null;
    opPatch: MetadataOperationType | null;
    opUpdate: MetadataOperationType | null;
    opDelete: MetadataOperationType | null;
    apiQuery: ApiState | null;
    apiCreate: ApiState | null;
    apiPatch: ApiState | null;
    apiUpdate: ApiState | null;
    apiDelete: ApiState | null;
};
export declare type CrudApisStateProp = CrudApisState & {
    prop: MetadataPropertyType;
    opName: string;
    dataModel: MetadataType;
    viewModel: MetadataType;
    viewModelColumns: MetadataPropertyType[];
    callback: Function;
    createPrefs: () => any;
    selectedColumns: (prefs: any) => MetadataPropertyType[];
};
/** Method arguments of custom Create Form Components */
export interface CreateComponentArgs {
    store: LocodeStore;
    routes: LocodeRoutes & LocodeRoutesExtend & Routes;
    settings: LocodeSettings;
    state: () => CrudApisState;
    save: () => void;
    done: () => void;
}
/** Method Signature of custom Create Form Components */
export declare type CreateComponent = (args: CreateComponentArgs) => Record<string, any>;
/** Method arguments of custom Edit Form Components */
export interface EditComponentArgs {
    store: LocodeStore;
    routes: LocodeRoutes & LocodeRoutesExtend & Routes;
    settings: LocodeSettings;
    state: () => CrudApisState;
    save: () => void;
    done: () => void;
}
/** Method signature of custom Edit Form Components */
export declare type EditComponent = (args: EditComponentArgs) => Record<string, any>;
/** Route methods used in Admin UI */
export declare type AdminRoutes = {
    tab?: string;
    provider?: string;
    q?: string;
    page?: string;
    sort?: string;
    new?: string;
    edit?: string;
};
/** App's primary reactive store maintaining global functionality for Admin UI */
export declare type AdminStore = {
    adminLink(string: any): LinkInfo;
    init(): void;
    cachedFetch(string: any): Promise<unknown>;
    debug: boolean;
    copied: boolean;
    auth: AuthenticateResponse | null;
    readonly authProfileUrl: string | null;
    readonly displayName: null;
    readonly link: LinkInfo;
    readonly isAdmin: boolean;
    login(any: any): void;
    readonly adminUsers: AdminUsersInfo;
    readonly authRoles: string[];
    filter: string;
    baseUrl: string;
    logout(): void;
    readonly authLinks: LinkInfo[];
    SignIn(): Function;
    readonly adminLinks: LinkInfo[];
    api: ApiResult<AuthenticateResponse> | null;
    readonly authPermissions: any;
};

/**
 * Alt solution to optional chaining by only executing fn accessor if object is not null
 * @example
 * let a = b()?.c // equivalent to:
 * let a = map(b(), x => x.c)
 * @template T,V
 * @param {T} o
 * @param {(T) => V} f
 * @return {V|null}
 */
export function map<T, V>(o: T, f: (T: any) => V): V;
/** Set class on document.body if truthy otherwise set `no{class}`
 * @param {{[key:string]:string|any}} obj */
export function setBodyClass(obj: {
    [key: string]: any;
}): void;
/** Get CSS style property value
 * @param {string} name */
export function styleProperty(name: string): string;
export function setStyleProperty(props: any): void;
/** Tailwind CSS classes for standard Input controls
 * @param {boolean} [invalid=false]
 * @param {string} [cls] */
export