[{"name":"Step.Decode","comment":" This module lets you decode data from STEP files in a similar way to how\nyou decode [JSON](https://package.elm-lang.org/packages/elm/json/latest/Json-Decode).\n\n\n# Decoder types\n\n@docs Decoder, FileDecoder, EntityDecoder, AttributeListDecoder, AttributeDecoder, Error\n\n\n# Decoding a file\n\n@docs file, header, single, all\n\n\n# Decoding an entity\n\n@docs entity\n\n\n# Decoding attribute lists\n\n@docs attribute\n\n\n# Decoding attributes\n\n@docs bool, int, float, string, enum, referenceTo, null, optional, list, tuple2, tuple3, derived\n\n\n## Typed attributes\n\n@docs boolAs, intAs, floatAs, stringAs, enumAs, listAs\n\n\n# Working with decoders\n\n@docs succeed, fail, map, map2, map3, map4, map5, map6, map7, map8, andThen, oneOf, lazy\n\n","unions":[{"name":"Decoder","comment":" A `Decoder` describes how to attempt to decode some input of type `i` (an\nentire file, an individual entity, a specific attribute) and produce some output\nof type `a`.\n\nEntity decoders have the additional ability to choose whether to _match_ a\nparticular entity. For example, a decoder for `CARTESIAN_POINT` entities would\n_fail_ if it encountered a `CARTESIAN_POINT` in an unexpected format (no XYZ\ncoordinates, for example) but would _not match_ a `DIRECTION` entity. This\ndistinction is important to avoid silently swallowing errors.\n\nThe `m` type parameter indicates whether a decoder has this ability to match or\nnot match inputs; it is equal to `String` for entity decoders and `Never`\notherwise.\n\nYou will rarely use the `Decoder` type directly in your own code, instead using\nthe specialized types such as `EntityDecoder`, but you will likely see it in\ncompiler error messages so it is useful to understand what the type parameters\nmean.\n\n","args":["i","m","a"],"cases":[]},{"name":"Error","comment":" Different kinds of errors that may be encountered when loading a STEP file:\n\n  - `ParseError`: the file could not be parsed as a valid STEP file.\n  - `NonexistentEntity`: one entity in the STEP file refers to another by\n    integer ID, but no entity with that ID exists in the file.\n  - `CircularReference`: There exists a circular chain of entities in the file\n    that refer to each other; the `List Int` is the list of entity IDs in the\n    chain.\n  - `DecodeError`: the file was parsed OK and all entity references were\n    resolved successfully, but an error occurred when running the given decoder.\n\n","args":[],"cases":[["ParseError",["String.String"]],["NonexistentEntity",["Basics.Int"]],["CircularReference",["List.List Basics.Int"]],["DecodeError",["String.String"]]]}],"aliases":[{"name":"AttributeDecoder","comment":" A `Decoder` that takes a single entity attribute as input and produces some\noutput.\n","args":["a"],"type":"Step.Decode.Decoder Step.Types.Attribute Basics.Never a"},{"name":"AttributeListDecoder","comment":" A `Decoder` that takes a list of entity attributes as input and produces\nsome output. The only `AttributeListDecoder` is [`attribute`](#attribute), which\nselects a particular attribute from the list by index and then applies a given\n`AttributeDecoder` to that attribute.\n","args":["a"],"type":"Step.Decode.Decoder (List.List Step.Types.Attribute) Basics.Never a"},{"name":"EntityDecoder","comment":" A `Decoder` that takes a STEP entity as input, chooses whether or not it\nshould 'match' that entity (generally based on the entity's type), and then (if\nit matches) decode that entity to produce some output.\n","args":["a"],"type":"Step.Decode.Decoder Step.Types.Entity String.String a"},{"name":"FileDecoder","comment":" A `Decoder` that takes an entire STEP file as input and produces some\noutput.\n","args":["a"],"type":"Step.Decode.Decoder Step.Types.File Basics.Never a"}],"values":[{"name":"all","comment":" Find all entities in a file matching the given decoder.\n","type":"Step.Decode.EntityDecoder a -> Step.Decode.FileDecoder (List.List a)"},{"name":"andThen","comment":" Run one decoder, and based on the result of the first decoder decide what\ndecoder to apply next. The only restriction is that this _second_ decoder must\nbe of a type that always matches (so not an [`entity`](#entity) decoder), since\nit is the _first_ decoder that decides whether to match the input or not.\n","type":"(a -> Step.Decode.Decoder i Basics.Never b) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b"},{"name":"attribute","comment":" Decode a specific attribute by index (starting from 0) in an attribute list.\nTo decode data from multiple attributes in a list, you can use one of the `mapN`\nfunctions, for example:\n\n    type alias MyAttributes =\n        { name : String\n        , age : Int\n        , height : Float\n        }\n\n    myAttributesDecoder : AttributeListDecoder MyAttributes\n    myAttributesDecoder =\n        Decode.map3 MyAttributes\n            (Decode.attribute 0 Decode.string)\n            (Decode.attribute 1 Decode.int)\n            (Decode.attribute 2 Decode.float)\n\n","type":"Basics.Int -> Step.Decode.AttributeDecoder a -> Step.Decode.AttributeListDecoder a"},{"name":"bool","comment":" Decode a single attribute as a `Bool` (from the special STEP enum values\n`.T.` and `.F.`).\n","type":"Step.Decode.AttributeDecoder Basics.Bool"},{"name":"boolAs","comment":" Decode a `Bool` wrapped as the given type.\n","type":"String.String -> Step.Decode.AttributeDecoder Basics.Bool"},{"name":"derived","comment":" Decode the special 'derived value' attribute (`*`) as the given value.\n","type":"a -> Step.Decode.AttributeDecoder a"},{"name":"entity","comment":" Decode an entity of the given type name, using the given decoder on the\nentity's list of attributes. If this decoder is passed to [`single`](#single) or\n[`all`](#all), any entities that do not have the given type will be skipped.\n","type":"String.String -> Step.Decode.AttributeListDecoder a -> Step.Decode.EntityDecoder a"},{"name":"enum","comment":" Decode a single enum attribute, by passing a list of enum cases as their\nSTEP type name and corresponding Elm value. For example, given a STEP enum with\nvalues `.RED.`, `.YELLOW.` and `.GREEN.` you might write:\n\n    type LightColor\n        = Red\n        | Yellow\n        | Green\n\n    lightColorDecoder : AttributeDecoder LightColor\n    lightColorDecoder =\n        Decode.enum\n            [ ( \"RED\", Red )\n            , ( \"YELLOW\", Yellow )\n            , ( \"GREEN\", Green )\n            ]\n\n(Note that the given strings will be normalized, so you do not have to worry\nabout upper vs. lower case and you can either include or omit the leading and\ntrailing periods.)\n\n","type":"List.List ( String.String, a ) -> Step.Decode.AttributeDecoder a"},{"name":"enumAs","comment":" Decode an enum wrapped as the given type.\n","type":"String.String -> List.List ( String.String, a ) -> Step.Decode.AttributeDecoder a"},{"name":"fail","comment":" A special decoder that always fails with the given error message.\n","type":"String.String -> Step.Decode.Decoder i m a"},{"name":"file","comment":" Decode a STEP file given as a `String` using the given decoder. For example,\nto extract the file header and all `CARTESIAN_POINT` entities from a given file,\nyou might write:\n\n    import Step.File\n    import Step.Decode as Decode exposing\n        ( Decoder\n        , FileDecoder\n        , EntityDecoder\n        )\n\n    type alias FileData =\n        { header : Step.File.Header\n        , points : List ( Float, Float, Float )\n        }\n\n    pointDecoder : EntityDecoder ( Float, Float, Float )\n    pointDecoder =\n        Decode.entity \"CARTESIAN_POINT\" <|\n            Decode.attribute 1 (Decode.tuple3 Decode.float)\n\n    fileDecoder : FileDecoder FileData\n    fileDecoder =\n        Decode.map2 FileData\n            Decode.header\n            (Decode.all pointDecoder)\n\n    fileContents : String\n    fileContents =\n        \"ISO-10303-21;...END-ISO-10303-21;\"\n\n    decoded : Result Decode.Error FileData\n    decoded =\n        Decode.file fileDecoder fileContents\n\n","type":"Step.Decode.FileDecoder a -> String.String -> Result.Result Step.Decode.Error a"},{"name":"float","comment":" Decode a single attribute as a `Float`. Note that unlike JSON, STEP has\ndifferent encodings for `Int` and `Float` values so you cannot use this\nfunction to decode integer values; if you want to decode an integer value as a\n`Float` you will need to use\n\n    Decode.map toFloat Decode.int\n\n","type":"Step.Decode.AttributeDecoder Basics.Float"},{"name":"floatAs","comment":" Decode a `Float` wrapped as the given type.\n","type":"String.String -> Step.Decode.AttributeDecoder Basics.Float"},{"name":"header","comment":" Extract the [header](Step-File#Header) of a STEP file.\n","type":"Step.Decode.FileDecoder Step.File.Header"},{"name":"int","comment":" Decode a single attribute as an `Int`.\n","type":"Step.Decode.AttributeDecoder Basics.Int"},{"name":"intAs","comment":" Decode an `Int` wrapped as the given type.\n","type":"String.String -> Step.Decode.AttributeDecoder Basics.Int"},{"name":"lazy","comment":" Define a decoder lazily such that it is only constructed if needed. This is\nprimarily used to break circular reference chains between decoders.\n","type":"(() -> Step.Decode.Decoder i m a) -> Step.Decode.Decoder i m a"},{"name":"list","comment":" Decode an attribute as a list, passing the decoder to be used for each list\nitem.\n","type":"Step.Decode.AttributeDecoder a -> Step.Decode.AttributeDecoder (List.List a)"},{"name":"listAs","comment":" Decode a list wrapped as the given type.\n","type":"String.String -> Step.Decode.AttributeDecoder a -> Step.Decode.AttributeDecoder (List.List a)"},{"name":"map","comment":" Map the value produced by a decoder.\n","type":"(a -> b) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b"},{"name":"map2","comment":" Map over two decoders.\n","type":"(a -> b -> c) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c"},{"name":"map3","comment":" Map over three decoders.\n","type":"(a -> b -> c -> d) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d"},{"name":"map4","comment":" Map over four decoders.\n","type":"(a -> b -> c -> d -> e) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d -> Step.Decode.Decoder i m e"},{"name":"map5","comment":" Map over five decoders.\n","type":"(a -> b -> c -> d -> e -> f) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d -> Step.Decode.Decoder i m e -> Step.Decode.Decoder i m f"},{"name":"map6","comment":" Map over six decoders.\n","type":"(a -> b -> c -> d -> e -> f -> g) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d -> Step.Decode.Decoder i m e -> Step.Decode.Decoder i m f -> Step.Decode.Decoder i m g"},{"name":"map7","comment":" Map over seven decoders.\n","type":"(a -> b -> c -> d -> e -> f -> g -> h) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d -> Step.Decode.Decoder i m e -> Step.Decode.Decoder i m f -> Step.Decode.Decoder i m g -> Step.Decode.Decoder i m h"},{"name":"map8","comment":" Map over eight decoders.\n","type":"(a -> b -> c -> d -> e -> f -> g -> h -> j) -> Step.Decode.Decoder i m a -> Step.Decode.Decoder i m b -> Step.Decode.Decoder i m c -> Step.Decode.Decoder i m d -> Step.Decode.Decoder i m e -> Step.Decode.Decoder i m f -> Step.Decode.Decoder i m g -> Step.Decode.Decoder i m h -> Step.Decode.Decoder i m j"},{"name":"null","comment":" Decode the special 'null' attribute (`$`) as the given value.\n","type":"a -> Step.Decode.AttributeDecoder a"},{"name":"oneOf","comment":" Construct an entity decoder that may match one of many entity types.\n","type":"List.List (Step.Decode.EntityDecoder a) -> Step.Decode.EntityDecoder a"},{"name":"optional","comment":" Decode an attribute that may be null, returning `Nothing` if it is.\n","type":"Step.Decode.AttributeDecoder a -> Step.Decode.AttributeDecoder (Maybe.Maybe a)"},{"name":"referenceTo","comment":" Decode an attribute which is a reference to another entity, by providing the\ndecoder to use for that entity.\n","type":"Step.Decode.EntityDecoder a -> Step.Decode.AttributeDecoder a"},{"name":"single","comment":" Attempt to find exactly one entity in a file that matches the given decoder.\nIf there are no matching entities or more than one matching entity, the decoder\nwill fail.\n","type":"Step.Decode.EntityDecoder a -> Step.Decode.FileDecoder a"},{"name":"string","comment":" Decode a single attribute as a `String`.\n","type":"Step.Decode.AttributeDecoder String.String"},{"name":"stringAs","comment":" Decode a `String` wrapped as the given type.\n","type":"String.String -> Step.Decode.AttributeDecoder String.String"},{"name":"succeed","comment":" A special decoder that always succeeds with the given value. Primarily\nuseful with [`andThen`](#andThen).\n","type":"a -> Step.Decode.Decoder i m a"},{"name":"tuple2","comment":" Decode a list of exactly two elements, passing the decoder to be used for\nthe two elements.\n","type":"Step.Decode.AttributeDecoder a -> Step.Decode.AttributeDecoder ( a, a )"},{"name":"tuple3","comment":" Decode a list of exactly three elements, passing the decoder to be used for\nthe three elements.\n","type":"Step.Decode.AttributeDecoder a -> Step.Decode.AttributeDecoder ( a, a, a )"}],"binops":[]},{"name":"Step.Encode","comment":" This module allows you to encode data in [ISO 10303-21](https://en.wikipedia.org/wiki/ISO_10303-21)\n(STEP file) format.\n\n\n## Example\n\nHere is a sample STEP file (adapted from [Wikipedia](https://en.wikipedia.org/wiki/ISO_10303-21#Example)):\n\n    ISO-10303-21;\n    HEADER;\n    FILE_DESCRIPTION(('A minimal AP214 example with a single part'),'2;1');\n    FILE_NAME('demo','2003-12-27T11:57:53',('Lothar Klein'),('LKSoft'),' ','IDA-STEP',' ');\n    FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 2 1 1}'));\n    ENDSEC;\n    DATA;\n    #10=ORGANIZATION('O0001','LKSoft','company');\n    #11=PRODUCT_DEFINITION_CONTEXT('part definition',#12,'manufacturing');\n    #12=APPLICATION_CONTEXT('mechanical design');\n    #13=APPLICATION_PROTOCOL_DEFINITION('','automotive_design',2003,#12);\n    #14=PRODUCT_DEFINITION('0',$,#15,#11);\n    #15=PRODUCT_DEFINITION_FORMATION('1',$,#16);\n    #16=PRODUCT('A0001','Test Part 1','',(#18));\n    #17=PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#16));\n    #18=PRODUCT_CONTEXT('',#12,'');\n    #19=APPLIED_ORGANIZATION_ASSIGNMENT(#10,#20,(#16));\n    #20=ORGANIZATION_ROLE('id owner');\n    ENDSEC;\n    END-ISO-10303-21;\n\nTo create this file using this package, you could write\n\n    module Example exposing (..)\n\n    import Step.Encode as Encode\n\n    stepFile : String\n    stepFile =\n        let\n            header =\n                { description = [ \"A minimal AP214 example with a single part\" ]\n                , implementationLevel = \"2;1\"\n                , fileName = \"demo\"\n                , timeStamp = \"2003-12-27T11:57:53\"\n                , author = [ \"Lothar Klein\" ]\n                , organization = [ \"LKSoft\" ]\n                , preprocessorVersion = \" \"\n                , originatingSystem = \"IDA-STEP\"\n                , authorization = \" \"\n                , schemaIdentifiers = [ \"AUTOMOTIVE_DESIGN { 1 0 10303 214 2 1 1}\" ]\n                }\n\n            applicationContext =\n                Encode.entity \"APPLICATION_CONTEXT\"\n                    [ Encode.string \"mechanical design\"\n                    ]\n\n            applicationProtocolDefinition =\n                Encode.entity \"APPLICATION_PROTOCOL_DEFINITION\"\n                    [ Encode.string \"\"\n                    , Encode.string \"automotive_design\"\n                    , Encode.int 2003\n                    , Encode.referenceTo applicationContext\n                    ]\n\n            product =\n                Encode.entity \"PRODUCT\"\n                    [ Encode.string \"A0001\"\n                    , Encode.string \"Test Part 1\"\n                    , Encode.string \"\"\n                    , Encode.list Encode.referenceTo\n                        [ Encode.entity \"PRODUCT_CONTEXT\"\n                            [ Encode.string \"\"\n                            , Encode.referenceTo applicationContext\n                            , Encode.string \"\"\n                            ]\n                        ]\n                    ]\n\n            productDefinition =\n                Encode.entity \"PRODUCT_DEFINITION\"\n                    [ Encode.string \"0\"\n                    , Encode.null\n                    , Encode.referenceTo <|\n                        Encode.entity \"PRODUCT_DEFINITION_FORMATION\"\n                            [ Encode.string \"1\"\n                            , Encode.null\n                            , Encode.referenceTo product\n                            ]\n                    , Encode.referenceTo <|\n                        Encode.entity \"PRODUCT_DEFINITION_CONTEXT\"\n                            [ Encode.string \"part definition\"\n                            , Encode.referenceTo applicationContext\n                            , Encode.string \"manufacturing\"\n                            ]\n                    ]\n\n            productRelatedProductCategory =\n                Encode.entity \"PRODUCT_RELATED_PRODUCT_CATEGORY\"\n                    [ Encode.string \"part\"\n                    , Encode.null\n                    , Encode.list Encode.referenceTo [ product ]\n                    ]\n\n            appliedOrganizationAssignment =\n                Encode.entity \"APPLIED_ORGANIZATION_ASSIGNMENT\"\n                    [ Encode.referenceTo <|\n                        Encode.entity \"ORGANIZATION\"\n                            [ Encode.string \"O0001\"\n                            , Encode.string \"LKSoft\"\n                            , Encode.string \"company\"\n                            ]\n                    , Encode.referenceTo <|\n                        Encode.entity \"ORGANIZATION_ROLE\"\n                            [ Encode.string \"id owner\"\n                            ]\n                    , Encode.list Encode.referenceTo [ product ]\n                    ]\n        in\n        Encode.file header\n            [ applicationContext\n            , applicationProtocolDefinition\n            , productDefinition\n            , productRelatedProductCategory\n            , appliedOrganizationAssignment\n            ]\n\nNote that entities can be declared directly 'inside' other entities where this\nmakes sense, and not all entities have to be explicitly listed in the\n`Encode.file` call, only top-level ones. Any entities directly or indirectly\nreferenced by the listed entities will also be included in the output. Entity\nIDs are automatically generated and entities may be written out in arbitrary\norder.\n\n@docs file\n\n\n# Entities\n\n@docs entity, complexEntity\n\n\n# Attributes\n\n@docs derived, null, optional, bool, int, float, string, referenceTo, enum, binary, list, tuple2, tuple3\n\n\n## Typed attributes\n\nTyped attributes are sometimes needed when dealing with SELECT types.\n\n@docs boolAs, intAs, floatAs, stringAs, enumAs, binaryAs, listAs\n\n","unions":[],"aliases":[],"values":[{"name":"binary","comment":" Construct a binary-valued attribute. The provided string is assumed to\nalready be hex encoded as required by the STEP standard.\n","type":"String.String -> Step.File.Attribute"},{"name":"binaryAs","comment":" Construct a type-tagged binary-valued attribute.\n","type":"String.String -> String.String -> Step.File.Attribute"},{"name":"bool","comment":" Construct a Boolean-valued attribute.\n\nBoolean values are actually encoded as enumeration values `.T.` and `.F.`.\n\n","type":"Basics.Bool -> Step.File.Attribute"},{"name":"boolAs","comment":" Construct a type-tagged Boolean-valued attribute.\n","type":"String.String -> Basics.Bool -> Step.File.Attribute"},{"name":"complexEntity","comment":" Construct a single 'complex entity'; for example\n\n    Encode.complexEntity\n        [ ( \"A\", [ Encode.int 1 ] )\n        , ( \"B\"\n          , [ Encode.int 2\n            , Encode.string \"three\"\n            ]\n          )\n        , ( \"C\", [ Encode.enum \"FOUR\" ] )\n        ]\n\nwill be encoded as\n\n    #1=(A(1)B(2,'three')C(.FOUR.));\n\n","type":"List.List ( String.String, List.List Step.File.Attribute ) -> Step.File.Entity"},{"name":"derived","comment":" The special 'derived value' attribute (`*` in the resulting STEP file).\n","type":"Step.File.Attribute"},{"name":"entity","comment":" Construct a single simple entity with the given type and attributes. The\ntype name will be capitalized if necessary. An [`IfcDirection`](http://www.buildingsmart-tech.org/ifc/IFC4/final/html/schema/ifcgeometryresource/lexical/ifcdirection.htm)\nrepresenting the positive Y direction in 3D could be created using\n\n    direction =\n        Encode.entity \"IFCDIRECTION\"\n            [ Encode.list Encode.float [ 0, 1, 0 ]\n            ]\n\nwhich might get encoded as `#1=IFCDIRECTION((0.,1.,0.));`.\n\nIf a given entity is _only_ referred to by a single other entity, you can create\nit directly inside the definition of the parent entity. For example, to create\nentity #121 from [this AP214 example](https://github.com/stepcode/stepcode/blob/master/data/ap214e3/as1-oc-214.stp),\nyou could use\n\n    Encode.entity \"AXIS2_PLACEMENT_3D\"\n        [ Encode.string \"\"\n        , Encode.referenceTo <|\n            Encode.entity \"CARTESIAN_POINT\"\n                [ Encode.string \"\"\n                , Encode.list Encode.float [ 20, 7.5, 0 ]\n                ]\n        , Encode.referenceTo <|\n            Encode.entity \"DIRECTION\"\n                [ Encode.string \"\"\n                , Encode.list Encode.float [ 1, 0, 0 ]\n                ]\n        , Encode.referenceTo <|\n            Encode.entity \"DIRECTION\"\n                [ Encode.string \"\"\n                , Encode.list Encode.float [ 0, 0, -1 ]\n                ]\n        ]\n\nWhen actually encoded to a STEP file, this will get converted into four separate\nentities, with the top-level entity referring to the other three by their\nautomatically-generated IDs, something like:\n\n    #1=AXIS2_PLACEMENT_3D('',#2,#3,#4);\n    #2=CARTESIAN_POINT('',(20.,7.5,0.));\n    #3=DIRECTION('',(1.,0.,0.));\n    #4=DIRECTION('',(0.,0.,-1.));\n\n","type":"String.String -> List.List Step.File.Attribute -> Step.File.Entity"},{"name":"enum","comment":" Construct an attribute that refers to an enumeration value defined in an\nEXPRESS schema. Enumeration values are always encoded as all-caps with leading\nand trailing periods, like `.STEEL.`.\n\nThis function will capitalize and add periods if necessary, so both\n`Encode.enum \"steel\"` and `Encode.enum \".STEEL.\"` will be encoded as\n`.STEEL.`.\n\n","type":"String.String -> Step.File.Attribute"},{"name":"enumAs","comment":" Construct a type-tagged enumeration attribute.\n","type":"String.String -> String.String -> Step.File.Attribute"},{"name":"file","comment":" Build a string representing a complete STEP file from a header and a list of\nentities. Entities will be assigned integer IDs automatically, and nested\nentities (entities that reference other entities) will be 'flattened' into\nseparate entities referring to each other by their automatically-generated IDs.\n\nNote that it is not actually necessary to list all entities explicitly, only\ntop-level ones; any entities that are referenced by entities in the given list\nwill also get included in the output.\n\n","type":"Step.File.Header -> List.List Step.File.Entity -> String.String"},{"name":"float","comment":" Construct a real-valued attribute.\n","type":"Basics.Float -> Step.File.Attribute"},{"name":"floatAs","comment":" Construct a type-tagged float-valued attribute.\n","type":"String.String -> Basics.Float -> Step.File.Attribute"},{"name":"int","comment":" Construct an integer-valued attribute.\n","type":"Basics.Int -> Step.File.Attribute"},{"name":"intAs","comment":" Construct a type-tagged integer-valued attribute.\n","type":"String.String -> Basics.Int -> Step.File.Attribute"},{"name":"list","comment":" Construct an attribute which is itself a list of other attributes. You\nprovide a list of values and a function to convert each of those values to an\nattribute (which will usually be one of the attribute construction functions in\nthis module!). For example, to construct an attribute which is a list of floats:\n\n    Encode.list Encode.float [ 0, 1, 0 ]\n\nTo construct a list of references to various entities:\n\n    Encode.list Encode.referenceTo\n        [ firstEntity\n        , secondEntity\n        , thirdEntity\n        ]\n\nIn the odd case where you already have a `List Attribute`, you can use Elm's\nbuilt-in `identity` function as the first argument:\n\n    Encode.list identity\n        [ firstAttribute\n        , secondAttribute\n        , thirdAttribute\n        ]\n\n","type":"(a -> Step.File.Attribute) -> List.List a -> Step.File.Attribute"},{"name":"listAs","comment":" Construct a type-tagged list attribute.\n","type":"String.String -> (a -> Step.File.Attribute) -> List.List a -> Step.File.Attribute"},{"name":"null","comment":" The special 'null value' attribute (`$` in the resulting STEP file).\n","type":"Step.File.Attribute"},{"name":"optional","comment":" Encode a `Maybe` either using the given decoder if it is a `Just value`, or\nas null if it is `Nothing`.\n","type":"(a -> Step.File.Attribute) -> Maybe.Maybe a -> Step.File.Attribute"},{"name":"referenceTo","comment":" Construct a reference to another STEP entity (will end up being encoded\nusing an integer ID in the resulting STEP file, e.g. `#123`).\n","type":"Step.File.Entity -> Step.File.Attribute"},{"name":"string","comment":" Construct a string-valued attribute. Unicode characters will be properly\nescaped according to the (weird, custom) method specified in the STEP standard;\nfor example,\n\n    Encode.string \"see § 4.1\"\n\nwill end up being encoded as\n\n    'see \\X\\A7 4.1'\n\n","type":"String.String -> Step.File.Attribute"},{"name":"stringAs","comment":" Construct a type-tagged string-valued attribute.\n","type":"String.String -> String.String -> Step.File.Attribute"},{"name":"tuple2","comment":" Encode a tuple of two values as a list using the given encoding function.\n","type":"(a -> Step.File.Attribute) -> ( a, a ) -> Step.File.Attribute"},{"name":"tuple3","comment":" Encode a tuple of three values as a list using the given encoding function.\n","type":"(a -> Step.File.Attribute) -> ( a, a, a ) -> Step.File.Attribute"}],"binops":[]},{"name":"Step.File","comment":" The types in this module are shared between the [`Encode`](Step-Encode) and\n[`Decode`](Step-Decode) modules.\n\n@docs File, Header, Entity, Attribute\n\n","unions":[],"aliases":[{"name":"Attribute","comment":" An `Attribute` represents a single attribute of an `Entity`, such as an X\ncoordinate value, a GUID string, or a reference to another entity.\n","args":[],"type":"Step.Types.Attribute"},{"name":"Entity","comment":" An `Entity` represents a single entity stored in the data section of a STEP\nfile. An entity may be a point, a curve, a part, an assembly, or even an entire\nbuilding. Entities may be 'simple' (having a type and a list of attributes,\nwhich can themselves be references to other entities) or 'complex' (effectively\na list of simple entities combined together).\n","args":[],"type":"Step.Types.Entity"},{"name":"File","comment":" Represents an entire STEP file composed of a header and a list of entities.\n","args":[],"type":"Step.Types.File"},{"name":"Header","comment":" A `Header` represents the data stored in the header section of a STEP file:\n\n  - `description` should be an informal description of the contents of the file.\n  - `implementationLevel` will typically be `\"2;1\"` indicating version 2 of\n    ISO 10303, conformance class 1 (which in turn means that the file has a\n    single data section and no anchor or reference sections, along with several\n    other restrictions). For other possible values, see section 8.2.2 of ISO\n    10303-21.\n  - `fileName` may be the file name of the actual file, or it may be an abstract\n    name for the contents of the file used when cross-referencing between files.\n  - `timeStamp` should be an\n    [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)-formatted date and time.\n  - `author` should include the name and address of the person who created the\n    file.\n  - `organization` should be the organization that the `author` is associated\n    with.\n  - One of `preprocessorVersion` or `originatingSystem` should identify what CAD\n    program was used to generate the file. This does not seem to be used\n    terribly consistently!\n  - `authorization` should include the name and address of whoever authorized\n    sending the file.\n  - `schemaIdentifiers` identifies the EXPRESS schema used by entities in the\n    file. This will usually be a list containing a single string, which may be\n    either a simple string like `\"IFC2X3\"` or an 'object identifier' such as\n    `\"AUTOMOTIVE\\_DESIGN { 1 0 10303 214 1 1 1 1 }\"` (more commonly known as\n    AP214).\n\n","args":[],"type":"{ description : List.List String.String, implementationLevel : String.String, fileName : String.String, timeStamp : String.String, author : List.List String.String, organization : List.List String.String, preprocessorVersion : String.String, originatingSystem : String.String, authorization : String.String, schemaIdentifiers : List.List String.String }"}],"values":[],"binops":[]}]