IFClite TypeScript API
    Preparing search index...

    Variable RuleConst

    Rule: {
        attribute: (
            name: string,
            op: ValueOp,
            value: string,
            valueKind?: TextKind,
        ) => AttributeRule;
        classification: (
            system: string,
            op: ClassificationOp,
            value: string,
            valueKind?: TextKind,
        ) => ClassificationRule;
        elevation: (op: NumericOp, value: number) => ElevationRule;
        globalId: (values: string[], op?: SetOp) => GlobalIdRule;
        group: typeof groupRule;
        ifcType: (values: string[], op?: SetOp) => IfcTypeRule;
        listCondition: typeof listConditionRule;
        material: (
            op: StringOp,
            value: string,
            valueKind?: TextKind,
        ) => MaterialRule;
        model: (values: string[], op?: SetOp) => ModelRule;
        modelFact: typeof modelFactRule;
        modelTag: (op: ModelTagOp, tagIds: string[]) => ModelTagRule;
        name: (op: StringOp, value: string, valueKind?: TextKind) => NameRule;
        parent: (op: StringOp, value: string, valueKind?: TextKind) => ParentRule;
        predefinedType: (values: string[], op?: SetOp) => PredefinedTypeRule;
        property: (
            setName: string,
            propertyName: string,
            op: ValueOp,
            value: string,
            kinds?: Pick<
                PropertyRule,
                "setNameKind"
                | "propertyNameKind"
                | "valueKind",
            >,
        ) => PropertyRule;
        quantity: (
            setName: string,
            quantityName: string,
            op: NumericOp,
            value: number,
            kinds?: Pick<QuantityRule, "setNameKind" | "quantityNameKind">,
        ) => QuantityRule;
        storey: (
            values: string[],
            op?: SetOp,
            refs?: ReadonlyArray<{ expressId: number; modelId: string }>,
        ) => StoreyRule;
        typeName: (
            op: StringOp,
            value: string,
            valueKind?: TextKind,
        ) => TypeNameRule;
    }

    Type Declaration