/// <reference path="../library/typings/cross-runtime.d.ts" />
/// <reference path="../typings/private/foundation-data-common.d.ts" />
/// <reference path="../typings/private/sk-data-logic.d.ts" />
/// <reference path="../typings/private/sk-data-resource.d.ts" />
/// <reference path="../typings/private/sk-data-family.d.ts" />
/// <reference path="../typings/private/sk-data-scheme.d.ts" />
/// <reference path="../typings/private/sk-data-calculate.d.ts" />
/// <reference path="../typings/private/sk-data-convert.d.ts" />
/// <reference path="../typings/private/sk-rule-data.d.ts" />
declare module "copyright" {
    export class RuleCalculateCopyright {
        static toString(): string;
    }
}
declare module "sk/rule/calculate/IndexSpace" {
    export class IndexSpace {
        static namespaces(): string[];
    }
}
declare module "sk/rule/calculate/quote/performer/ElementCalculatorResult" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CalculatorResult } from 'foundation/core/module/calculator/CalculatorResult';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { CalculateElementPerformerContext } from 'sk/rule/data/base/CalculateElementPerformerContext';
    export class ElementCalculatorResult extends CalculatorResult {
        context: CalculateElementPerformerContext;
        nodes: Types<DataNode>;
        constructor(context?: CalculateElementPerformerContext);
        addNode(node: DataNode): void;
    }
}
declare module "sk/rule/calculate/quote/SchemeQuotePlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class SchemeQuotePlain extends WorkflowPlainProcess {
        document: FamilyDocument;
        processElement(context: any, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}
declare module "sk/rule/calculate/scheme/rule/service/parameter/DecodeParamterService" {
    import { DataTypeEnum } from 'cross/runtime/lang/DataTypeEnum';
    import { Service } from 'cross/runtime/module/Service';
    export class ParamterDecoder {
        decoder(value: string): any;
    }
    export class ParamterStringDecoder extends ParamterDecoder {
    }
    export class ParamterFloat32Decoder extends ParamterDecoder {
        decoder(value: string): any;
    }
    export class DecodeParamerService extends Service {
        private _decorders;
        constructor();
        findDecorder(dataType: DataTypeEnum): ParamterDecoder;
    }
}
declare module "sk/rule/calculate/scheme/rule/service/parameter/ParameterStructure" {
    import { DataTypeEnum } from 'cross/runtime/lang/DataTypeEnum';
    export class ParameterStructure {
        dataname: string;
        name: string;
        dataType: DataTypeEnum;
        constructor(dataname: string, type: DataTypeEnum);
    }
}
declare module "sk/rule/calculate/scheme/rule/service/parameter/ParamterPropertyService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { ParameterStructure } from "sk/rule/calculate/scheme/rule/service/parameter/ParameterStructure";
    export class ParameterPropertyService extends Service {
        private _parameterMaps;
        constructor();
        register(clazz: Function, paramter: ParameterStructure): void;
        findParamterArray(clazz: Function): Types<ParameterStructure>;
    }
}
declare module "sk/rule/calculate/scheme/rule/service/parameter/ParameterDeclare" {
    import { DataTypeEnum } from 'cross/runtime/lang/DataTypeEnum';
    export function ParameterDeclare(dataName: string, dataCd?: DataTypeEnum): (target: any, name: string) => void;
}
declare module "sk/rule/calculate/scheme/rule/service/process/ProcessInputBoard" {
    import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
    export class ProcessInputBoard extends InstanceObject {
    }
}
declare module "sk/rule/calculate/scheme/rule/service/parameter/RuleProcessParameterUtil" {
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    import { ProcessInputBoard } from "sk/rule/calculate/scheme/rule/service/process/ProcessInputBoard";
    export class RuleProcessParameterUtil {
        static decodeInputParameters(input: RuleProcessInput, board: ProcessInputBoard): void;
    }
}
declare module "sk/rule/calculate/scheme/rule/service/process/RuleProcessService" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { Service } from 'cross/runtime/module/Service';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    export type RuleProcessDeclareInfo = {
        name: string;
        clazz: any;
    };
    export class RuleProcessService extends Service {
        protected _declares: Types<RuleProcessDeclareInfo>;
        findDeclareByName(name: string): RuleProcessDeclareInfo;
        findProcessInstance(name: string): RuleProcess;
        registerDeclare(name: string, clazz: any): void;
    }
}
declare module "sk/rule/calculate/scheme/rule/service/process/RuleProcessDeclare" {
    export function RuleProcessDeclare(name: string): (type: any) => void;
}
declare module "sk/rule/calculate/scheme/technique/performer/ElementCalculatorResult" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CalculatorResult } from 'foundation/core/module/calculator/CalculatorResult';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { CalculateElementPerformerContext } from 'sk/rule/data/base/CalculateElementPerformerContext';
    export class ElementCalculatorResult extends CalculatorResult {
        context: CalculateElementPerformerContext;
        nodes: Types<DataNode>;
        constructor(context?: CalculateElementPerformerContext);
        addNode(node: DataNode): void;
    }
}
declare module "sk/rule/calculate/scheme/validate/performer/ElementCalculatorResult" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CalculatorResult } from 'foundation/core/module/calculator/CalculatorResult';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { CalculateElementPerformerContext } from 'sk/rule/data/base/CalculateElementPerformerContext';
    export class ElementCalculatorResult extends CalculatorResult {
        context: CalculateElementPerformerContext;
        nodes: Types<DataNode>;
        constructor(context?: CalculateElementPerformerContext);
        addNode(node: DataNode): void;
    }
}
declare module "sk/rule/calculate/scheme/validate/rule/SchemeSceneValidation" {
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { SchemeGlobalRuleProcessOutput } from 'sk/rule/data/base/rule/SchemeGlobalRuleProcessOutput';
    import { SchemeRuleProcessContext } from 'sk/rule/data/base/rule/SchemeRuleProcessContext';
    import { SchemeRuleProcessInput } from 'sk/rule/data/base/rule/SchemeRuleProcessInput';
    export class SchemeSceneValidation extends RuleProcess {
        checkFamilyInstanceElementAsync(element: FamilyInstanceElement): Promise<void>;
        checkElementAsync(element: Element): Promise<boolean>;
        processAsync(context: SchemeRuleProcessContext, input: SchemeRuleProcessInput, output: SchemeGlobalRuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/calculate/scheme/validate/rule/TestValidateRuleProcess" {
    import { GlobalRuleProcessOutput } from 'sk/data/family/rule/process/GlobalRuleProcessOutput';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    export class TestValidateRuleProcess extends RuleProcess {
        processAsync(context: RuleProcessContext, input: RuleProcessInput, output: GlobalRuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/calculate/scheme/validate/rule/VerificationDistanceLineRule" {
    import { GlobalRuleProcessOutput } from 'sk/data/family/rule/process/GlobalRuleProcessOutput';
    import { RuleProcesResult } from 'sk/data/family/rule/process/RuleProcesResult';
    import { RuleProcess } from 'sk/data/family/rule/process/RuleProcess';
    import { RuleProcessContext } from 'sk/data/family/rule/process/RuleProcessContext';
    import { RuleProcessInput } from 'sk/data/family/rule/process/RuleProcessInput';
    export class VerificationDistanceLineRule extends RuleProcess {
        processAsync(context: RuleProcessContext, input: RuleProcessInput, output: GlobalRuleProcessOutput): Promise<RuleProcesResult>;
    }
}
declare module "sk/rule/calculate/structure/performer/ElementCalculatorResult" {
    import { Types } from 'cross/runtime/lang/collection/Types';
    import { CalculatorResult } from 'foundation/core/module/calculator/CalculatorResult';
    import { DataNode } from 'foundation/data/common/model/base/DataNode';
    import { CalculateElementPerformerContext } from 'sk/rule/data/base/CalculateElementPerformerContext';
    export class ElementCalculatorResult extends CalculatorResult {
        context: CalculateElementPerformerContext;
        nodes: Types<DataNode>;
        constructor(context?: CalculateElementPerformerContext);
        addNode(node: DataNode): void;
    }
}
declare module "sk/rule/calculate/structure/SchemeStructurePlain" {
    import { ResultEnum } from 'cross/runtime/lang/ResultEnum';
    import { WorkflowPlainProcess } from 'foundation/data/common/workflow/base/WorkflowPlainProcess';
    import { WorkflowPlainResult } from 'foundation/data/common/workflow/base/WorkflowPlainResult';
    import { WorkflowPlainContext } from 'foundation/data/common/workflow/process/WorkflowPlainContext';
    import { Element } from 'sk/data/family/element/base/Element';
    import { FamilyDocument } from 'sk/data/family/library/FamilyDocument';
    export class SchemeStructurePlain extends WorkflowPlainProcess {
        document: FamilyDocument;
        processElement(context: any, element: Element, isBefore: boolean): ResultEnum;
        process(context: WorkflowPlainContext): WorkflowPlainResult;
    }
}