metanorma-iso 1.9.5 → 1.9.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (18) hide show
  1. checksums.yaml +4 -4
  2. data/lib/asciidoctor/iso/basicdoc.rng +21 -4
  3. data/lib/asciidoctor/iso/front.rb +9 -1
  4. data/lib/asciidoctor/iso/isodoc.rng +192 -50
  5. data/lib/asciidoctor/iso/isostandard.rng +6 -22
  6. data/lib/asciidoctor/iso/reqt.rng +23 -2
  7. data/lib/isodoc/iso/html/isodoc.css +1 -2
  8. data/lib/isodoc/iso/html/isodoc.scss +1 -1
  9. data/lib/isodoc/iso/html/wordstyle.css +16 -4
  10. data/lib/isodoc/iso/html/wordstyle.scss +16 -4
  11. data/lib/isodoc/iso/iso.amendment.xsl +12 -2
  12. data/lib/isodoc/iso/iso.international-standard.xsl +12 -2
  13. data/lib/metanorma/iso/version.rb +1 -1
  14. data/metanorma-iso.gemspec +3 -1
  15. data/spec/asciidoctor/base_spec.rb +351 -124
  16. data/spec/spec_helper.rb +12 -0
  17. data/spec/vcr_cassettes/docrels.yml +393 -0
  18. metadata +31 -2
data/spec/vcr_cassettes/docrels.yml ADDED
@@ -0,0 +1,393 @@
1
+ ---
2
+ http_interactions:
3
+ - request:
4
+ method: post
5
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
6
+ body:
7
+ encoding: UTF-8
8
+ string: '{"query":"ISO 125","hitsPerPage":100,"filters":"category:standard"}'
9
+ headers:
10
+ User-Agent:
11
+ - Algolia for Ruby (2.1.1), Ruby (2.7.2)
12
+ X-Algolia-Api-Key:
13
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
14
+ X-Algolia-Application-Id:
15
+ - JCL49WV5AR
16
+ Content-Type:
17
+ - application/json; charset=utf-8
18
+ Accept-Encoding:
19
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
20
+ Accept:
21
+ - "*/*"
22
+ Connection:
23
+ - keep-alive
24
+ Keep-Alive:
25
+ - '30'
26
+ response:
27
+ status:
28
+ code: 200
29
+ message: OK
30
+ headers:
31
+ Server:
32
+ - nginx
33
+ Date:
34
+ - Sat, 09 Oct 2021 16:54:04 GMT
35
+ Content-Type:
36
+ - application/json; charset=UTF-8
37
+ Transfer-Encoding:
38
+ - chunked
39
+ Connection:
40
+ - keep-alive
41
+ X-Alg-Pt:
42
+ - '1'
43
+ Accept-Encoding:
44
+ - deflate, gzip
45
+ Cache-Control:
46
+ - no-store
47
+ Access-Control-Allow-Origin:
48
+ - "*"
49
+ Timing-Allow-Origin:
50
+ - "*"
51
+ X-Content-Type-Options:
52
+ - nosniff
53
+ Strict-Transport-Security:
54
+ - max-age=31536000; includeSubDomains; preload
55
+ Content-Disposition:
56
+ - inline; filename=a.txt
57
+ body:
58
+ encoding: ASCII-8BIT
59
+ string: !binary |-
60
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/28/72849","uuid":"14819547-4274-4772-96fd-13a48f9559a0","title":"ISO 125:2020 Natural rubber latex concentrate — Determination of alkalinity","status":"Published","year":2020,"order":11,"text":"This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in ISO 13773. ","objectID":"72849_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2020 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in <em>ISO</em> 13773. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/92/59265","uuid":"555cf5b2-606b-4fb0-a80f-0cd3dd2ff916","title":"ISO 125:2011 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2020,"order":100,"text":"ISO 125:2011 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","objectID":"59265_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2011 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>:2011 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/70/27006","uuid":"8b786006-44e1-44af-abaf-d1cfa5b43881","title":"ISO 125:2003 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2011,"order":100,"text":"ISO 125:2003 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","objectID":"27006_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2003 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>:2003 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3931","uuid":"df9a2ef4-f3cd-4203-9f5e-1cab903195d1","title":"ISO 125:1990 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2003,"order":100,"text":"Covers the method for materials which contain preservative agents and have been submitted to some type of concentration process. Replaces the second edition (ISO 125-1977). ","objectID":"3931_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1990 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Covers the method for materials which contain preservative agents and have been submitted to some type of concentration process. Replaces the second edition (<em>ISO</em> <em>125</em>-1977). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3930","uuid":"8014c0c4-04b2-45f4-b650-d92194bf9a19","title":"ISO 125:1983 Rubber latex, natural — Determination of alkalinity","status":"Withdrawn","year":1990,"order":100,"objectID":"3930_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1983 Rubber latex, natural — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/20/72090","uuid":"8a16ecd1-73bf-4f32-9c09-fec5b403ec1e","title":"ISO 12511:1997/Amd 1:2021 Earth-moving machinery — Hour meters — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"72090_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>11:1997/Amd 1:2021 Earth-moving machinery — Hour meters — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/49/64988","uuid":"fc4e9639-6999-4e9e-a2c2-1c043980f5a5","title":"ISO 12572:2016 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties — Cup method","status":"Published","year":2021,"order":11,"text":"ISO 12572:2016 specifies a method based on cup tests for determining the water vapour permeance of building products and the water vapour permeability of building materials under isothermal conditions. Different sets of test conditions are specified. The general principles are applicable to all hygroscopic and non-hygroscopic building materials and products, including insulation materials and including those with facings and integral skins. Annexes give details of test methods suitable for different material types. The results obtained by this method are suitable for design purposes, production control and for inclusion in product specifications. ","objectID":"64988_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>72:2016 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties — Cup method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>72:2016 specifies a method based on cup tests for determining the water vapour permeance of building products and the water vapour permeability of building materials under isothermal conditions. Different sets of test conditions are specified. The general principles are applicable to all hygroscopic and non-hygroscopic building materials and products, including insulation materials and including those with facings and integral skins. Annexes give details of test methods suitable for different material types. The results obtained by this method are suitable for design purposes, production control and for inclusion in product specifications. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/15/61598","uuid":"348ddefe-eeba-416a-a4a5-764aaaed0f0a","title":"ISO 12578:2016 Timber structures — Glued laminated timber — Component performance requirements","status":"Published","year":2021,"order":11,"text":"ISO 12578:2016 specifies requirements for the components of glued laminated timber members for structural use. ISO 12578:2016 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, this International Standard also applies to broad leaf species if the tests specified in this International Standard show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather resistant adhesives (see 5.3). ISO 12578:2016 does not apply to the determination of strength and stiffness characteristics. Annex B contains informative materials for formaldehyde emission. ","objectID":"61598_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>78:2016 Timber structures — Glued laminated timber — Component performance requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>78:2016 specifies requirements for the components of glued laminated timber members for structural use. <em>ISO</em> <em>125</em>78:2016 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, this International Standard also applies to broad leaf species if the tests specified in this International Standard show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather resistant adhesives (see 5.3). <em>ISO</em> <em>125</em>78:2016 does not apply to the determination of strength and stiffness characteristics. Annex B contains informative materials for formaldehyde emission. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/01/60178","uuid":"3b12f72a-90ef-4b31-8924-b041b2f872af","title":"ISO 12505-1:2014 Skin barrier for ostomy aids — Test methods — Part 1: Size, surface pH and water-absorbency","status":"Published","year":2021,"order":11,"text":"ISO 12505-1:2014 specifies test methods dealing with a face plate of skin barriers for ostomy aids. ","objectID":"60178_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>05-1:2014 Skin barrier for ostomy aids — Test methods — Part 1: Size, surface pH and water-absorbency","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>05-1:2014 specifies test methods dealing with a face plate of skin barriers for ostomy aids. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51529","uuid":"fd619bd6-bb2d-4424-8351-f4a25ffcd3e8","title":"ISO 12573:2010 Aircraft — Tubing tolerances — Inch series","status":"Published","year":2021,"order":11,"text":"ISO 12573:2010 specifies the dimensional tolerances to be applied to round section inch series tubing used in aircraft. ","objectID":"51529_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>73:2010 Aircraft — Tubing tolerances — Inch series","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>73:2010 specifies the dimensional tolerances to be applied to round section inch series tubing used in aircraft. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/07/20776","uuid":"4fea251f-7465-48de-9c0a-8698d9377c2a","title":"ISO 12508:1994 Earth-moving machinery — Operator station and maintenance areas — Bluntness of edges","status":"Published","year":2021,"order":11,"text":"Defines the permissible limits of the sharpness of edges and corners, so reduce the risk of injury to the operator or maintenance personnel while operating earth-moving machinery and performing maintenance. ","objectID":"20776_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>08:1994 Earth-moving machinery — Operator station and maintenance areas — Bluntness of edges","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Defines the permissible limits of the sharpness of edges and corners, so reduce the risk of injury to the operator or maintenance personnel while operating earth-moving machinery and performing maintenance. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51530","uuid":"6393b16c-0b35-42fd-b488-d99091245312","title":"ISO 12584:2013 Aerospace — Hydraulic fluid components — Expression of particulate contamination levels","status":"Published","year":2020,"order":11,"text":"ISO 12584:2013 defines the method of reporting and communicating the contamination (or cleanliness) level of components used in aerospace fluid systems. It also presents a coding system which allows cleanliness data to be reported, both in a shortened manner and in a complete manner, when communicating for reporting contamination level measurement results and for specifying cleanliness requirements. ","objectID":"51530_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>84:2013 Aerospace — Hydraulic fluid components — Expression of particulate contamination levels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>84:2013 defines the method of reporting and communicating the contamination (or cleanliness) level of components used in aerospace fluid systems. It also presents a coding system which allows cleanliness data to be reported, both in a shortened manner and in a complete manner, when communicating for reporting contamination level measurement results and for specifying cleanliness requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/03/50327","uuid":"87e4c965-686a-472a-8178-8337a06c0dd5","title":"ISO 12567-1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors","status":"Published","year":2020,"order":11,"text":"ISO 12567-1:2010 specifies a method to measure the thermal transmittance of a door or window system. It is applicable to all effects of frames, sashes, shutters, blinds, screens, panels, door leaves and fittings. It is not applicable to edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen, effects of air leakage through the specimen, and roof windows and projecting products, where the external face projects beyond the cold side roof surface. ","objectID":"50327_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>67-1:2010 specifies a method to measure the thermal transmittance of a door or window system. It is applicable to all effects of frames, sashes, shutters, blinds, screens, panels, door leaves and fittings. It is not applicable to edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen, effects of air leakage through the specimen, and roof windows and projecting products, where the external face projects beyond the cold side roof surface. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/41/44113","uuid":"89e3e265-69e2-4690-bd85-81b819f1f253","title":"ISO 12500-3:2009 Filters for compressed air — Test methods — Part 3: Particulates","status":"Published","year":2020,"order":11,"text":"ISO 12500-3:2009 provides a guide for choosing an appropriate method of determining the solid particulate removal efficiency rating by particle size of filters used in compressed air systems. ISO 12500-3:2009 specifies the layouts and procedures for testing these filters. Measurement methods are recommended based on the size range of the particulates that the filter being tested has been designed to remove. The test is performed as a “type-test” on filters as being representative of a range. The following two particle diameter size ranges are identified in ISO 12500-3:2009: a fine filter range, 0,01 < 5,0 μm, and a coarse filter range, ≥ 5,0 ≤ 40 μm. ","objectID":"44113_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-3:2009 Filters for compressed air — Test methods — Part 3: Particulates","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-3:2009 provides a guide for choosing an appropriate method of determining the solid particulate removal efficiency rating by particle size of filters used in compressed air systems. <em>ISO</em> <em>125</em>00-3:2009 specifies the layouts and procedures for testing these filters. Measurement methods are recommended based on the size range of the particulates that the filter being tested has been designed to remove. The test is performed as a “type-test” on filters as being representative of a range. The following two particle diameter size ranges are identified in <em>ISO</em> <em>125</em>00-3:2009: a fine filter range, 0,01 < 5,0 μm, and a coarse filter range, ≥ 5,0 ≤ 40 μm. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/11/41150","uuid":"6d5b04cd-7f35-4200-aab2-a6e4b123e149","title":"ISO 12500-1:2007 Filters for compressed air —  Test methods — Part 1: Oil aerosols","status":"Published","year":2020,"order":11,"text":"ISO 12500-1:2007 specifies the test layout and test procedures required for testing coalescing filters used in compressed-air systems to determine their effectiveness in removing oil aerosols. ISO 12500-1:2007 provides the means to indicate performance characteristics of the pressure drop and the capability of removing oil aerosols. ISO 12500-1:2007 defines one method of presenting filter performance as outlet oil aerosol concentration stated in milligrams per cubic metre from results obtained under standard rating parameters. ","objectID":"41150_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-1:2007 Filters for compressed air —  Test methods — Part 1: Oil aerosols","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-1:2007 specifies the test layout and test procedures required for testing coalescing filters used in compressed-air systems to determine their effectiveness in removing oil aerosols. <em>ISO</em> <em>125</em>00-1:2007 provides the means to indicate performance characteristics of the pressure drop and the capability of removing oil aerosols. <em>ISO</em> <em>125</em>00-1:2007 defines one method of presenting filter performance as outlet oil aerosol concentration stated in milligrams per cubic metre from results obtained under standard rating parameters. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/13/61388","uuid":"18c94541-5190-4037-9d2f-dd669278ab4a","title":"ISO 12571:2013 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Published","year":2019,"order":11,"text":"ISO 12571:2013 specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. ISO 12571:2013 does not specify the method for sampling. The methods specified in ISO 12571:2013 can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","objectID":"61388_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71:2013 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>71:2013 specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. <em>ISO</em> <em>125</em>71:2013 does not specify the method for sampling. The methods specified in <em>ISO</em> <em>125</em>71:2013 can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/08/40843","uuid":"c054d880-188c-4abb-ba21-cca2a8e2157a","title":"ISO 12580:2007 Timber structures — Glued laminated timber — Methods of test for glue-line delamination","status":"Published","year":2019,"order":11,"text":"ISO 12580:2007 specifies five delamination methods for factory quality assurance of the glue line of glued laminated timber. ","objectID":"40843_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>80:2007 Timber structures — Glued laminated timber — Methods of test for glue-line delamination","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>80:2007 specifies five delamination methods for factory quality assurance of the glue line of glued laminated timber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/03/40330","uuid":"c1bb57fb-1b4d-4700-a553-970a33b0df21","title":"ISO 12509:2004 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","status":"Published","year":2019,"order":11,"text":"ISO 12509:2004 specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth moving machines. It is applicable to self-propelled wheel or crawler earth-moving machines as defined in ISO 6165, intended for off-road, as well as on-road, use. It is not applicable to pedestrian-controlled machines. ","objectID":"40330_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>09:2004 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>09:2004 specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth moving machines. It is applicable to self-propelled wheel or crawler earth-moving machines as defined in <em>ISO</em> 6165, intended for off-road, as well as on-road, use. It is not applicable to pedestrian-controlled machines. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/00/40053","uuid":"a853358f-73ba-4813-aaac-c4861338ab10","title":"ISO 12567-2:2005 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 2: Roof windows and other projecting windows","status":"Published","year":2019,"order":11,"text":"ISO 12567-2:2005 specifies a method to measure the thermal transmittance of roof windows and projecting windows. It does not include: edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen and effects of air leakage through the specimen. ","objectID":"40053_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-2:2005 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 2: Roof windows and other projecting windows","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>67-2:2005 specifies a method to measure the thermal transmittance of roof windows and projecting windows. It does not include: edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen and effects of air leakage through the specimen. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2565","uuid":"74c73339-92b6-4593-9cd8-92647a146434","title":"ISO 12576-1:2001 Thermal insulation — Insulating materials and products for buildings — Conformity control systems — Part 1: Factory-made products","status":"Published","year":2019,"order":11,"text":"This part of ISO 12576 establishes five systems for the conformity control of thermal insulating materials and products for buildings that are factory made. Its purpose is to provide uniform methods that are used to determine whether a production or a consignment of a thermal insulating material should be accepted as conforming to the relevant specification requirements. This part of ISO 12576 provides minimum requirements for each of the systems. Other systems may be additionally applied when agreed upon between the supplier and purchaser. ","objectID":"2565_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>76-1:2001 Thermal insulation — Insulating materials and products for buildings — Conformity control systems — Part 1: Factory-made products","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This part of <em>ISO</em> <em>125</em>76 establishes five systems for the conformity control of thermal insulating materials and products for buildings that are factory made. Its purpose is to provide uniform methods that are used to determine whether a production or a consignment of a thermal insulating material should be accepted as conforming to the relevant specification requirements. This part of <em>ISO</em> <em>125</em>76 provides minimum requirements for each of the systems. Other systems may be additionally applied when agreed upon between the supplier and purchaser. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/24/2444","uuid":"ca8ea987-fe87-4cf1-9a1c-62facb484665","title":"ISO 12570:2000 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature","status":"Published","year":2019,"order":11,"objectID":"2444_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/21/2133","uuid":"71ccf225-8d6e-4bd3-81a6-ae12332af3b3","title":"ISO 12511:1997 Earth-moving machinery — Hour meters","status":"Published","year":2019,"order":11,"objectID":"2133_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>11:1997 Earth-moving machinery — Hour meters","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/24/72409","uuid":"f7038083-239b-4fbd-98d5-1f6070862731","title":"ISO 12570:2000/Amd 2:2018 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 2","status":"Published","year":2018,"order":11,"objectID":"72409_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000/Amd 2:2018 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 2","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46380","uuid":"30992f55-09d0-4752-a8db-659847517c2b","title":"ISO 12543-6:2011 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Published","year":2018,"order":11,"text":"ISO 12543-6:2011 specifies defects of finished sizes and test methods with regard to the appearance of laminated glass when looking through the glass. ISO 12543-6:2011 is applicable to finished sizes at the time of supply. ","objectID":"46380_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:2011 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-6:2011 specifies defects of finished sizes and test methods with regard to the appearance of laminated glass when looking through the glass. <em>ISO</em> <em>125</em>43-6:2011 is applicable to finished sizes at the time of supply. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46379","uuid":"11750bd0-e628-4c2a-9995-f96ef6138eed","title":"ISO 12543-5:2011 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Published","year":2018,"order":11,"text":"ISO 12543-5:2011 specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. ","objectID":"46379_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-5:2011 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-5:2011 specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46378","uuid":"0513c926-322b-4293-accf-0533a189d00d","title":"ISO 12543-4:2011 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Published","year":2018,"order":11,"text":"ISO 12543-4:2011 specifies test methods in respect of resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","objectID":"46378_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4:2011 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-4:2011 specifies test methods in respect of resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46377","uuid":"b4f82b67-ee82-44d5-bd5f-352d2325f92b","title":"ISO 12543-3:2011 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Published","year":2018,"order":11,"text":"ISO 12543-3:2011 specifies performance requirements for laminated glass as defined in ISO 12543-1. ","objectID":"46377_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3:2011 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-3:2011 specifies performance requirements for laminated glass as defined in <em>ISO</em> <em>125</em>43-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46376","uuid":"8a44c9c8-2e29-4af7-9d40-aa1fa3be8459","title":"ISO 12543-2:2011 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Published","year":2018,"order":11,"text":"ISO 12543-2:2011 specifies performance requirements for laminated safety glass as defined in ISO 12543-1. ","objectID":"46376_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2:2011 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-2:2011 specifies performance requirements for laminated safety glass as defined in <em>ISO</em> <em>125</em>43-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/57/45746","uuid":"e4cc0fc7-b28a-4061-a1e8-c9486f90d4cb","title":"ISO 12576-2:2008 Thermal insulation products — Conformity control systems — Part 2: In-situ products","status":"Published","year":2018,"order":11,"text":"ISO 12576-2:2008 establishes three systems for the conformity control of thermal insulating products that are manufactured on-site from components produced in a factory and provides the minimum requirements for each system. Examples of these types of products are loose fill and spray-applied insulations. The purpose of ISO 12576-2:2008 is to provide uniform methods to determine whether the production of a thermal-insulating product is acceptable as conforming to the relevant specification requirements once it is installed on site. ","objectID":"45746_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>76-2:2008 Thermal insulation products — Conformity control systems — Part 2: In-situ products","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>76-2:2008 establishes three systems for the conformity control of thermal insulating products that are manufactured on-site from components produced in a factory and provides the minimum requirements for each system. Examples of these types of products are loose fill and spray-applied insulations. The purpose of <em>ISO</em> <em>125</em>76-2:2008 is to provide uniform methods to determine whether the production of a thermal-insulating product is acceptable as conforming to the relevant specification requirements once it is installed on site. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40543","uuid":"ba88a7d9-053b-49f4-90fa-6fe4fb741eeb","title":"ISO 12575-2:2007 Thermal insulation products — Exterior  insulating systems for foundations — Part 2: Principal responsibilities of installers","status":"Published","year":2018,"order":11,"text":"ISO 12575-2:2007 specifies the responsibilities of the installers of exterior insulating systems for foundations such that a product that is manufactured and packaged in accordance with ISO 12575-1 is able to provide the properties declared by the manufacturer when installed according to ISO 12575-2:2007. ISO 12575-2:2007 stipulates responsibilities of the installer in the installation of the exterior insulation system, documentation of the installation and a declaration by the installer that all requirements of ISO 12575-2:2007 have been met. ISO 12575-2:2007 does not specify the fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in ISO 12575-1. The installer can be required to meet additional requirements specified in local regulations or the customer's requirements. ","objectID":"40543_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>75-2:2007 Thermal insulation products — Exterior  insulating systems for foundations — Part 2: Principal responsibilities of installers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>75-2:2007 specifies the responsibilities of the installers of exterior insulating systems for foundations such that a product that is manufactured and packaged in accordance with <em>ISO</em> <em>125</em>75-1 is able to provide the properties declared by the manufacturer when installed according to <em>ISO</em> <em>125</em>75-2:2007. <em>ISO</em> <em>125</em>75-2:2007 stipulates responsibilities of the installer in the installation of the exterior insulation system, documentation of the installation and a declaration by the installer that all requirements of <em>ISO</em> <em>125</em>75-2:2007 have been met. <em>ISO</em> <em>125</em>75-2:2007 does not specify the fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in <em>ISO</em> <em>125</em>75-1. The installer can be required to meet additional requirements specified in local regulations or the customer's requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40542","uuid":"cb6077e5-845b-440f-8923-897c8f03becd","title":"ISO 12575-1:2012 Thermal insulation products — Exterior insulating systems for foundations — Part 1: Material specification","status":"Published","year":2018,"order":11,"text":"ISO 12575-1:2012 specifies the basic performance requirements for the insulating materials that form part of insulating systems used on the exterior of foundations and slabs where the insulation is in direct contact with the ground. ISO 12575-1:2012 does not address exterior insulating systems for foundations permanently immersed in water. ","objectID":"40542_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>75-1:2012 Thermal insulation products — Exterior insulating systems for foundations — Part 1: Material specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>75-1:2012 specifies the basic performance requirements for the insulating materials that form part of insulating systems used on the exterior of foundations and slabs where the insulation is in direct contact with the ground. <em>ISO</em> <em>125</em>75-1:2012 does not address exterior insulating systems for foundations permanently immersed in water. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/24/32428","uuid":"f917d126-4907-4c9e-b35d-1fd2865aed8a","title":"ISO 12510:2004 Earth-moving machinery — Operation and maintenance — Maintainability guidelines","status":"Published","year":2018,"order":11,"text":"ISO 12510:2004 establishes guidelines for the incorporation of design features that promote safety, efficiency, reliability and ease of maintenance and service operations on earth-moving machinery as defined in ISO 6165. ","objectID":"32428_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>10:2004 Earth-moving machinery — Operation and maintenance — Maintainability guidelines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>10:2004 establishes guidelines for the incorporation of design features that promote safety, efficiency, reliability and ease of maintenance and service operations on earth-moving machinery as defined in <em>ISO</em> 6165. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/98/69817","uuid":"b0700e2d-1de9-42fe-834d-65274f841436","title":"ISO 12569:2017 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Published","year":2017,"order":11,"text":"ISO 12569:2017 establishes methods to obtain the ventilation rate or specific airflow rate in a building space (which is considered to be a single zone) using a tracer gas. The measurement methods apply for spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. ISO 12569:2017 provides three measurement methods using a tracer gas: concentration decay method, continuous dose method, and constant concentration method. NOTE          Specific measurement conditions are given in Table 1. ","objectID":"69817_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2017 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>69:2017 establishes methods to obtain the ventilation rate or specific airflow rate in a building space (which is considered to be a single zone) using a tracer gas. The measurement methods apply for spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. <em>ISO</em> <em>125</em>69:2017 provides three measurement methods using a tracer gas: concentration decay method, continuous dose method, and constant concentration method. NOTE          Specific measurement conditions are given in Table 1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/25/62574","uuid":"b2c4da80-02ac-46c2-aa23-67926d79dcc6","title":"ISO 12540:2017 Glass in building — Tempered soda lime silicate safety glass","status":"Published","year":2017,"order":11,"text":"ISO 12540:2017 covers product definitions, product characteristics, i.e. tolerances, flatness, edgework, etc., fracture characteristics, including fragmentation, and the physical and mechanical characteristics of flat tempered soda lime silicate safety glass for use in buildings. ISO 12540:2017 does not cover curved (bent) glass according to ISO 11485. Other requirements, not specified in this document, can apply to thermally toughened soda lime silicate safety glass which is incorporated into assemblies, e.g. laminated glass or insulating glass units, or undergo an additional treatment, e.g. coating. The additional requirements are specified in the appropriate glass product standard. Thermally toughened soda lime silicate safety glass, in this case, does not lose its mechanical or thermal characteristics. ","objectID":"62574_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>40:2017 Glass in building — Tempered soda lime silicate safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>40:2017 covers product definitions, product characteristics, i.e. tolerances, flatness, edgework, etc., fracture characteristics, including fragmentation, and the physical and mechanical characteristics of flat tempered soda lime silicate safety glass for use in buildings. <em>ISO</em> <em>125</em>40:2017 does not cover curved (bent) glass according to <em>ISO</em> 11485. Other requirements, not specified in this document, can apply to thermally toughened soda lime silicate safety glass which is incorporated into assemblies, e.g. laminated glass or insulating glass units, or undergo an additional treatment, e.g. coating. The additional requirements are specified in the appropriate glass product standard. Thermally toughened soda lime silicate safety glass, in this case, does not lose its mechanical or thermal characteristics. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/04/50473","uuid":"b74f62a6-9e76-4be0-841f-ae1e0f934a6e","title":"ISO 12500-4:2009 Filters for compressed air — Methods of test — Part 4: Water","status":"Published","year":2017,"order":11,"text":"The test method described in ISO 12500-4:2009 is designed to determine the water-removal efficiency and operational pressure drop of any device designed for water removal from compressed air described as wall flow in accordance with ISO 8573-2. ","objectID":"50473_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-4:2009 Filters for compressed air — Methods of test — Part 4: Water","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"The test method described in <em>ISO</em> <em>125</em>00-4:2009 is designed to determine the water-removal efficiency and operational pressure drop of any device designed for water removal from compressed air described as wall flow in accordance with <em>ISO</em> 8573-2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/11/41151","uuid":"47363d72-0931-4770-9afa-44044ab65bf4","title":"ISO 12500-2:2007 Filters for compressed air — Test methods — Part 2: Oil vapours","status":"Published","year":2017,"order":11,"text":"ISO 12500-2:2007 specifies the test layout and test procedures required for testing hydrocarbon vapour adsorbent filters used in compressed air systems to determine their effectiveness in removing hydrocarbon vapours. The performance characteristics to be identified are the adsorptive capacity and the pressure drop. ISO 12500-2:2007 defines one method of presenting filter performance as hydrocarbon-vapour capacity, expressed in milligrams, from results obtained under test conditions. ","objectID":"41151_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-2:2007 Filters for compressed air — Test methods — Part 2: Oil vapours","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-2:2007 specifies the test layout and test procedures required for testing hydrocarbon vapour adsorbent filters used in compressed air systems to determine their effectiveness in removing hydrocarbon vapours. The performance characteristics to be identified are the adsorptive capacity and the pressure drop. <em>ISO</em> <em>125</em>00-2:2007 defines one method of presenting filter performance as hydrocarbon-vapour capacity, expressed in milligrams, from results obtained under test conditions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/08/40842","uuid":"1ff9e0e1-f4b0-4325-9009-0c13115ae4da","title":"ISO 12579:2007 Timber structures — Glued laminated timber — Method of test for shear strength of glue lines","status":"Published","year":2017,"order":11,"text":"ISO 12579:2007 specifies a production quality-control test method for measuring the shear strength of the glue line of glued laminated timber. ","objectID":"40842_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>79:2007 Timber structures — Glued laminated timber — Method of test for shear strength of glue lines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>79:2007 specifies a production quality-control test method for measuring the shear strength of the glue line of glued laminated timber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/84/68415","uuid":"01d7b214-9da5-4e44-b158-6bceaac0dc37","title":"ISO 12505-2:2016 Skin barrier for ostomy aids — Test methods — Part 2: Wet integrity and adhesive strength","status":"Published","year":2016,"order":11,"text":"ISO 12505-2:2016 specifies test methods dealing with face plates of skin barriers for ostomy aids. ISO 12505-2:2016 does not cover medical properties (cytotoxicity, sensitization, irritation/intracutaneous reactivity, buffering effect, microbiological effects, etc.). ","objectID":"68415_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>05-2:2016 Skin barrier for ostomy aids — Test methods — Part 2: Wet integrity and adhesive strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>05-2:2016 specifies test methods dealing with face plates of skin barriers for ostomy aids. <em>ISO</em> <em>125</em>05-2:2016 does not cover medical properties (cytotoxicity, sensitization, irritation/intracutaneous reactivity, buffering effect, microbiological effects, etc.). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46375","uuid":"102885a1-1f79-4b67-b258-cdc0bf9f0b3f","title":"ISO 12543-1:2011 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","status":"Published","year":2016,"order":11,"text":"ISO 12543-1:2011 defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","objectID":"46375_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1:2011 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-1:2011 defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/79/57974","uuid":"731fe194-8e9a-4b29-adfe-65c4ec604b67","title":"ISO 12570:2000/Amd 1:2013 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 1","status":"Published","year":2013,"order":11,"objectID":"57974_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000/Amd 1:2013 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/15/61531","uuid":"43b2f7c7-2075-448c-a950-2a0c9a6effd2","title":"ISO 12543-6:2011/Cor 1:2012 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance — Technical Corrigendum 1","status":"Published","year":2012,"order":11,"objectID":"61531_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:2011/Cor 1:2012 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/72/57224","uuid":"f0f4210c-0761-40ec-99e9-65c0358e98bc","title":"ISO 12567-1:2010/Cor 1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors — Technical Corrigendum 1","status":"Published","year":2010,"order":11,"objectID":"57224_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2010/Cor 1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/95/79595","uuid":"f8577a09-6841-4ab3-a003-c8e59da08c43","title":"ISO 12571 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Under development","year":2021,"order":12,"objectID":"79595_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/55/75501","uuid":"88f93119-1a89-49b7-800f-3c720cdb9ee5","title":"ISO 12543-6 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Under development","year":2021,"order":12,"objectID":"75501_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75499","uuid":"7f8ae6c7-185e-452d-b871-280e17e2b9a2","title":"ISO 12543-4 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Under development","year":2021,"order":12,"objectID":"75499_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75498","uuid":"6a3eecfa-05b4-46ef-a465-b851c433e06b","title":"ISO 12543-3 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Under development","year":2021,"order":12,"objectID":"75498_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75497","uuid":"f085ce52-8c1c-4868-b348-2987a1a2b618","title":"ISO 12543-2 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Under development","year":2021,"order":12,"objectID":"75497_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/28/72871","uuid":"37257217-0b94-457a-ba48-5cced0197f71","title":"ISO 12543-1 Glass in building — Laminated glass and laminated safety glass — Part 1: Vocabulary and description of component parts","status":"Under development","year":2021,"order":12,"objectID":"72871_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1 Glass in building — Laminated glass and laminated safety glass — Part 1: Vocabulary and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/46/74661","uuid":"451f1bea-68a0-4551-8db5-ea52058d8f26","title":"ISO 12569:2017/DAmd 1 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method — Amendment 1","status":"Deleted","year":2019,"order":100,"objectID":"74661_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2017/DAmd 1 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40546","uuid":"0267bfed-e73c-4e9a-b4fa-94539ebad444","title":"ISO 12574-2:2008 Thermal insulation — Cellulose-fibre loose-fill for horizontal applications in ventilated roof spaces — Part 2: Principal responsibilities of installers","status":"Withdrawn","year":2019,"order":100,"text":"ISO 12574-2:2008 gives the principal responsibilities of the installers of cellulose-fibre loose-fill thermal insulation products for buildings. If a product is manufactured and packaged according to ISO 12574-1 and then installed in ventilated roof spaces as described in ISO 9774, it is expected to provide the properties declared by the manufacturer. ISO 12574-2:2008 gives the principal responsibilities of the installer in the installation of the product, in the documentation of the installation and in the declaration that all requirements of this part of ISO 12574 have been met. ISO 12574-2:2008 does not specify fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in government regulations. It is necessary that the installer ensure, when installing the product, that the product installed is suitable for the application, based on the government regulations and the manufacturer's recommendations. The installer can be required to meet ancillary (additional) requirements that are specified in local regulations or the customer's requirements. ","objectID":"40546_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>74-2:2008 Thermal insulation — Cellulose-fibre loose-fill for horizontal applications in ventilated roof spaces — Part 2: Principal responsibilities of installers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>74-2:2008 gives the principal responsibilities of the installers of cellulose-fibre loose-fill thermal insulation products for buildings. If a product is manufactured and packaged according to <em>ISO</em> <em>125</em>74-1 and then installed in ventilated roof spaces as described in <em>ISO</em> 9774, it is expected to provide the properties declared by the manufacturer. <em>ISO</em> <em>125</em>74-2:2008 gives the principal responsibilities of the installer in the installation of the product, in the documentation of the installation and in the declaration that all requirements of this part of <em>ISO</em> <em>125</em>74 have been met. <em>ISO</em> <em>125</em>74-2:2008 does not specify fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in government regulations. It is necessary that the installer ensure, when installing the product, that the product installed is suitable for the application, based on the government regulations and the manufacturer's recommendations. The installer can be required to meet ancillary (additional) requirements that are specified in local regulations or the customer's requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/64/56470","uuid":"18869879-5ac6-45f4-80c9-4df41565704c","title":"ISO 12569:2012 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Withdrawn","year":2017,"order":100,"text":"ISO 12569:2012 establishes an engineering standard by which to obtain the ventilation rate/specific airflow rate, using a tracer gas in a building space, which is considered to be of a single zone. The measurement method is valid in spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. ISO 12569:2012 provides three measurement methods using a tracer gas: (1) concentration decay method, (2) continuous dose method, and (3) constant concentration method. ","objectID":"56470_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2012 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>69:2012 establishes an engineering standard by which to obtain the ventilation rate/specific airflow rate, using a tracer gas in a building space, which is considered to be of a single zone. The measurement method is valid in spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. <em>ISO</em> <em>125</em>69:2012 provides three measurement methods using a tracer gas: (1) concentration decay method, (2) continuous dose method, and (3) constant concentration method. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/09/40959","uuid":"6f35ecbd-20ac-43b8-8e30-082493d73471","title":"ISO 12578:2008 Timber structures — Glued laminated timber — Component performance and production requirements","status":"Withdrawn","year":2016,"order":100,"text":"ISO 12578:2008 specifies requirements for the components of glued laminated timber members and minimum requirements for the production of such members for structural use. ISO 12578:2008 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, ISO 12578:2008 also applies to broad-leaf species if the tests specified in ISO 12578:2008 show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather-resistant adhesives. ISO 12578:2008 does not apply to the determination of strength and stiffness characteristics. ","objectID":"40959_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>78:2008 Timber structures — Glued laminated timber — Component performance and production requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>78:2008 specifies requirements for the components of glued laminated timber members and minimum requirements for the production of such members for structural use. <em>ISO</em> <em>125</em>78:2008 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, <em>ISO</em> <em>125</em>78:2008 also applies to broad-leaf species if the tests specified in <em>ISO</em> <em>125</em>78:2008 show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather-resistant adhesives. <em>ISO</em> <em>125</em>78:2008 does not apply to the determination of strength and stiffness characteristics. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/40/34000","uuid":"16256905-ac81-42aa-a444-30aef87617dd","title":"ISO 12572:2001 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties","status":"Withdrawn","year":2016,"order":100,"objectID":"34000_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>72:2001 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/24/2408","uuid":"78f10b8b-d573-4f2f-a3b3-424218e85e02","title":"ISO 12571:2000 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Withdrawn","year":2013,"order":100,"objectID":"2408_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71:2000 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/33/33382","uuid":"80415c8d-6c9a-4762-9fa4-70d7ac54f446","title":"ISO 12569:2000 Thermal performance of buildings — Determination of air change in buildings — Tracer gas dilution method","status":"Withdrawn","year":2012,"order":100,"objectID":"33382_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2000 Thermal performance of buildings — Determination of air change in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/83/38329","uuid":"19d1b031-fa87-4e60-8a90-119280567111","title":"ISO 12543-2:2004 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Withdrawn","year":2011,"order":100,"text":"ISO 12543-2:2004 specifies performance requirements for laminated safety glass. ","objectID":"38329_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2:2004 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-2:2004 specifies performance requirements for laminated safety glass. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25265","uuid":"f72b4d08-2c3d-4e5a-ac43-b3ebab4b4745","title":"ISO 12543-6:1998 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Withdrawn","year":2011,"order":100,"objectID":"25265_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:1998 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25259","uuid":"1a36bb5e-a501-4586-b588-8512884cb17d","title":"ISO 12543-5:1998 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Withdrawn","year":2011,"order":100,"objectID":"25259_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-5:1998 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25258","uuid":"2e5e4c67-c2cb-4e58-a665-aabd2032e014","title":"ISO 12543-4:1998 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Withdrawn","year":2011,"order":100,"objectID":"25258_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4:1998 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25257","uuid":"bbb27051-4616-4506-b267-7cf7f3ff815f","title":"ISO 12543-3:1998 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Withdrawn","year":2011,"order":100,"objectID":"25257_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3:1998 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/17/1705","uuid":"a7a06ef8-9f85-422d-b7aa-e6511cb436cf","title":"ISO 12543-1:1998 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","status":"Withdrawn","year":2011,"order":100,"objectID":"1705_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1:1998 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2533","uuid":"c3373f51-7c94-444c-84a0-66281b73853f","title":"ISO 12567-1:2000 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 1: Complete windows and doors","status":"Withdrawn","year":2010,"order":100,"objectID":"2533_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2000 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 1: Complete windows and doors","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/18/1845","uuid":"04379487-f548-4427-aa83-0f9b2c388eeb","title":"ISO 12509:1995 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","status":"Withdrawn","year":2004,"order":100,"text":"Specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth-moving machines. Applies to self-propelled wheel or crawler earth-moving machines as defined in ISO 6165, intended for off-road use as well as on-road use. Does not include pedestrian controlled machines. ","objectID":"1845_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>09:1995 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth-moving machines. Applies to self-propelled wheel or crawler earth-moving machines as defined in <em>ISO</em> 6165, intended for off-road use as well as on-road use. Does not include pedestrian controlled machines. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5864","uuid":"6aec10b4-9ce2-40a4-ac69-1ea0f2ef8d3a","title":"ISO 1250:1972 Mineral solvents for paints — White spirits and related hydrocarbon solvents","status":"Withdrawn","year":1985,"order":100,"objectID":"5864_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>0:1972 Mineral solvents for paints — White spirits and related hydrocarbon solvents","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/09/70904","uuid":"95e7b0fa-f3ae-4b29-a184-3001dd504ae7","title":"ISO 7783:2018 Paints and varnishes — Determination of water-vapour transmission properties — Cup method","status":"Published","year":2018,"order":11,"text":"This document specifies a method for determining the water-vapour transmission properties of coatings of paints, varnishes and related products. It supplements ISO 12572. As far as possible, the procedure, the definitions and the calculations have been taken over from ISO 12572. ISO 12572 can be consulted, if necessary, to obtain a better understanding of the procedure specified in this document. Water-vapour transmission rates of more than 680 g/(m2⋅d) (i.e. water-vapour diffusion-equivalent air layer thicknesses, sd, of less than 0,03 m) are not accurately quantified by the test method described in this document. ","objectID":"70904_0","_highlightResult":{"title":{"value":"<em>ISO</em> 7783:2018 Paints and varnishes — Determination of water-vapour transmission properties — Cup method","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies a method for determining the water-vapour transmission properties of coatings of paints, varnishes and related products. It supplements <em>ISO</em> <em>125</em>72. As far as possible, the procedure, the definitions and the calculations have been taken over from <em>ISO</em> <em>125</em>72. <em>ISO</em> <em>125</em>72 can be consulted, if necessary, to obtain a better understanding of the procedure specified in this document. Water-vapour transmission rates of more than 680 g/(m2⋅d) (i.e. water-vapour diffusion-equivalent air layer thicknesses, sd, of less than 0,03 m) are not accurately quantified by the test method described in this document. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/14/61432","uuid":"ad73d9c6-1290-4a71-ab64-def1780a89a3","title":"ISO 18100:2017 Timber structures — Finger-jointed timber — Manufacturing and production requirements","status":"Published","year":2017,"order":11,"text":"ISO 18100:2017 specifies the product and performance requirements for finger-jointed structural timber made from sawn timber elements. ISO 18100:2017 does not cover products made using impressed (die-formed) joints or finger-jointed laminations for glued laminated timber, which is covered in ISO 12578. ","objectID":"61432_0","_highlightResult":{"title":{"value":"<em>ISO</em> 18100:2017 Timber structures — Finger-jointed timber — Manufacturing and production requirements","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 18100:2017 specifies the product and performance requirements for finger-jointed structural timber made from sawn timber elements. <em>ISO</em> 18100:2017 does not cover products made using impressed (die-formed) joints or finger-jointed laminations for glued laminated timber, which is covered in <em>ISO</em> <em>125</em>78. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/48/64839","uuid":"ee7465a7-59be-4dee-9573-888ae8f10eca","title":"ISO 9241-125:2017 Ergonomics of human-system interaction — Part 125: Guidance on visual presentation of information","status":"Published","year":2017,"order":11,"text":"ISO 9241-125:2017 provides guidance for the visual presentation of information controlled by software, irrespective of the device. It includes specific properties such as the syntactic or semantic aspects of information, e.g. coding techniques, and gives provisions for the organization of information taking account of human perception and memory capabilities. Those of its provisions that do not apply to specific types of visual interfaces clearly indicate any limitations to their applicability. It does not address specific details of charts, graphs or information visualization. ISO 9241-125:2017 can be utilized throughout the design process (e.g. as specification and guidance for designers during design or as a basis for heuristic evaluation). Its provisions for the presentation of information depend upon the visual design approach, the task, the user, the environment and the single or multiple technologies that might be used for presenting the information. Consequently, this document cannot be applied without knowledge of the context of use. It is not intended to be used as a prescriptive set of rules to be applied in its entirety but rather assumes that the designer has proper information available concerning task and user requirements and understands the use of available technology. Some of the provisions of this document are based on Latin-based language usage and might not apply, or might need to be modified, for use with languages that use other alphabets. In applying those that assume a specific language base (e.g. alphabetic ordering of coding information, items in a list), it is important that care is taken to follow its intent of the standard when translation is required to a different language. ISO 9241-125:2017 does not address auditory or tactile/haptic presentation of information or modality shifting for the presentation of visual information in other modalities. NOTE       ISO 9241‑112 provides high-level ergonomic guidance that applies to all modalities. ","objectID":"64839_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9241-<em>125</em>:2017 Ergonomics of human-system interaction — Part <em>125</em>: Guidance on visual presentation of information","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> 9241-<em>125</em>:2017 provides guidance for the visual presentation of information controlled by software, irrespective of the device. It includes specific properties such as the syntactic or semantic aspects of information, e.g. coding techniques, and gives provisions for the organization of information taking account of human perception and memory capabilities. Those of its provisions that do not apply to specific types of visual interfaces clearly indicate any limitations to their applicability. It does not address specific details of charts, graphs or information visualization. <em>ISO</em> 9241-<em>125</em>:2017 can be utilized throughout the design process (e.g. as specification and guidance for designers during design or as a basis for heuristic evaluation). Its provisions for the presentation of information depend upon the visual design approach, the task, the user, the environment and the single or multiple technologies that might be used for presenting the information. Consequently, this document cannot be applied without knowledge of the context of use. It is not intended to be used as a prescriptive set of rules to be applied in its entirety but rather assumes that the designer has proper information available concerning task and user requirements and understands the use of available technology. Some of the provisions of this document are based on Latin-based language usage and might not apply, or might need to be modified, for use with languages that use other alphabets. In applying those that assume a specific language base (e.g. alphabetic ordering of coding information, items in a list), it is important that care is taken to follow its intent of the standard when translation is required to a different language. <em>ISO</em> 9241-<em>125</em>:2017 does not address auditory or tactile/haptic presentation of information or modality shifting for the presentation of visual information in other modalities. NOTE       <em>ISO</em> 9241‑112 provides high-level ergonomic guidance that applies to all modalities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/67/66763","uuid":"31b1fee8-1773-4b75-b2fb-7f6b71f63dde","title":"ISO/TS 12512:2017 Glass reinforced thermosetting plastic (GRP) pipes — Determination of initial specific ring stiffness using segment test species cut from a pipe","status":"Published","year":2021,"order":11,"text":"ISO/TS 12512:2017 specifies a method for determining the initial specific ring stiffness of pipes having a nominal size of DN 2000 or larger, using segment test pieces cut from a glass-reinforced thermosetting plastics (GRP) pipe. ","objectID":"66763_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS <em>125</em>12:2017 Glass reinforced thermosetting plastic (GRP) pipes — Determination of initial specific ring stiffness using segment test species cut from a pipe","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS <em>125</em>12:2017 specifies a method for determining the initial specific ring stiffness of pipes having a nominal size of DN 2000 or larger, using segment test pieces cut from a glass-reinforced thermosetting plastics (GRP) pipe. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51542","uuid":"43e413ae-7681-42c9-9d72-d8f978fdf4ae","title":"ISO/TR 12591:2013 White tea — Definition","status":"Published","year":2020,"order":11,"text":"ISO/TR 12591:2013 contains information regarding the manufacture and chemical analysis of the tea referred to as white tea in international trade. It provides an internationally agreed definition of white tea based on the plant source and production methods used. ","objectID":"51542_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>91:2013 White tea — Definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TR <em>125</em>91:2013 contains information regarding the manufacture and chemical analysis of the tea referred to as white tea in international trade. It provides an internationally agreed definition of white tea based on the plant source and production methods used. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77689","uuid":"e7fe71f4-fa0a-4479-aedd-d5ad37045e1c","title":"ISO/DIS 12509 Earth-moving machinery and rough-terrain trucks — Lighting, signalling and marking lights, and reflex reflector devices","status":"Under development","year":2021,"order":12,"objectID":"77689_0","_highlightResult":{"title":{"value":"<em>ISO</em>/DIS <em>125</em>09 Earth-moving machinery and rough-terrain trucks — Lighting, signalling and marking lights, and reflex reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/55/75500","uuid":"439a9e94-bfe3-4f78-990c-924ff4ee4c91","title":"ISO/FDIS 12543-5 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Under development","year":2021,"order":12,"objectID":"75500_0","_highlightResult":{"title":{"value":"<em>ISO</em>/FDIS <em>125</em>43-5 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/04/80461","uuid":"384fd8fe-353d-4cc7-b879-6cc4e28872b4","title":"ISO/AWI 12569 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Under development","year":2020,"order":12,"objectID":"80461_0","_highlightResult":{"title":{"value":"<em>ISO</em>/AWI <em>125</em>69 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/75/77531","uuid":"2f9e9389-6de8-4d4a-9382-0f4d751f1dcc","title":"ISO/CD 12591 White tea — Definition and basic requirements","status":"Deleted","year":2020,"order":100,"objectID":"77531_0","_highlightResult":{"title":{"value":"<em>ISO</em>/CD <em>125</em>91 White tea — Definition and basic requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/77/27742","uuid":"5c6efdc5-f537-4bc0-8c36-3c4e71192165","title":"ISO/TR 12596:1995/Cor 1:1996 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines — Technical Corrigendum 1","status":"Withdrawn","year":2005,"order":100,"text":"Replaces the equation in note 6. ","objectID":"27742_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>96:1995/Cor 1:1996 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Replaces the equation in note 6. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/20/2020","uuid":"620b8716-8169-471e-940d-dfcee08c8094","title":"ISO/TR 12596:1995 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines","status":"Withdrawn","year":2005,"order":100,"text":"Gives recommendations for the design, installation and commissioning of solar heating systems for swimming pools, using direct circulation of pool water to the solar collectors. Does not include electrical safety requirements and does not deal with the pool filtration systems. ","objectID":"2020_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>96:1995 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Gives recommendations for the design, installation and commissioning of solar heating systems for swimming pools, using direct circulation of pool water to the solar collectors. Does not include electrical safety requirements and does not deal with the pool filtration systems. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52641","uuid":"97d15797-0739-4cb4-989b-045b9a71bbb7","title":"ISO/TS 10303-1252:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1252: Application module: Probability","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1252:2010-03 specifies the application module for\n         Probability. The following are within the scope of \n         ISO/TS 10303-1252:2010-03: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","objectID":"52641_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>2: Application module: Probability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2010-03 specifies the application module for\n         Probability. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>2:2010-03: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38992","uuid":"c28a2d0e-191d-443e-8576-dbc4910c4713","title":"ISO/TS 10303-1254:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1254: Application module: Condition evaluation","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1254:2004 specifies the application module for\n         Condition evaluation. The following are within the scope of \n         ISO/TS 10303-1254:2004: identification of the evaluation of a condition specified by a textual\n                 description that resulted in a logical; recording of parameter values evaluated and the logical result of\n                 the evaluation. ","objectID":"38992_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>4:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>4: Application module: Condition evaluation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>4:2004 specifies the application module for\n         Condition evaluation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>4:2004: identification of the evaluation of a condition specified by a textual\n                 description that resulted in a logical; recording of parameter values evaluated and the logical result of\n                 the evaluation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38990","uuid":"56ce79f3-f7da-4f74-80e0-887f3cae22a5","title":"ISO/TS 10303-1257:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1257: Application module: Condition characterized","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1257:2004 specifies the application module for\n         Condition characterized. The following are within the scope of \n         ISO/TS 10303-1257:2004: approval assignments; date and time information; identification assignment; person and organization information; assignment of properties. ","objectID":"38990_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>7:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>7: Application module: Condition characterized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>7:2004 specifies the application module for\n         Condition characterized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>7:2004: approval assignments; date and time information; identification assignment; person and organization information; assignment of properties. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78628","uuid":"e0cbaa7f-f8a1-42e2-8b12-b0b7f2208bb6","title":"ISO/TS 10303-1259:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1259: Application module: Activity as realized","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1259:2019 specifies the application module for\n         Activity as realized. The following are within the scope of \n         ISO/TS 10303-1259:2019: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","objectID":"78628_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>9: Application module: Activity as realized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2019 specifies the application module for\n         Activity as realized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>9:2019: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78627","uuid":"f1d2f0a2-982c-4997-9387-eb2b2134e692","title":"ISO/TS 10303-1256:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1256: Application module: State observed","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1256:2019 specifies the application module for\n         State observed. The following are within the scope of \n         ISO/TS 10303-1256:2019: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","objectID":"78627_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>6: Application module: State observed","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2019 specifies the application module for\n         State observed. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>6:2019: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78626","uuid":"471a1fac-1693-4320-95d7-45e46232dd27","title":"ISO/TS 10303-1253:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1253:2019 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2019: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"78626_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2019 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2019: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78625","uuid":"3d97eaf9-780a-40eb-a156-335c3e72b651","title":"ISO/TS 10303-1251:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1251:2019 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2019: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"78625_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2019 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2019: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60633","uuid":"0fe35040-5f6b-4927-b344-b5fbba72df2d","title":"ISO/TS 10303-1258:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1258:2011-10 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2011-10: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"60633_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2011-10 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2011-10: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60632","uuid":"0ca6c985-f766-44e3-b32b-2d9ee00046a7","title":"ISO/TS 10303-1255:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1255: Application module: State definition","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1255:2011-10 specifies the application module for\n         State definition. The following are within the scope of \n         ISO/TS 10303-1255:2011-10: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","objectID":"60632_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>5: Application module: State definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2011-10 specifies the application module for\n         State definition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>5:2011-10: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/73/77379","uuid":"cf143ce5-f0bd-4b33-899b-580b18b1be06","title":"ISO/TS 10303-1250:2018 Industrial automation systems and integration — Product data representation and exchange — Part 1250: Application module: Attachment slot","status":"Published","year":2018,"order":11,"text":"ISO/TS 10303-1250:2018-11 specifies the application module for\n         Attachment slot. The following are within the scope of \n         ISO/TS 10303-1250:2018-11: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","objectID":"77379_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2018 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>0: Application module: Attachment slot","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2018-11 specifies the application module for\n         Attachment slot. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>0:2018-11: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/73/77381","uuid":"8966f023-55a6-432d-a989-d059870debb8","title":"ISO/TS 10303-1253:2018 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1253:2018-11 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2018-11: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"77381_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2018 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2018-11 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2018-11: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60631","uuid":"11a98f1c-a4fd-4655-b67c-25235933f643","title":"ISO/TS 10303-1251:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1251:2011-10 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2011-10: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"60631_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2011-10 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2011-10: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/62/56237","uuid":"07a7b68a-8558-4763-871b-7a2d3322233d","title":"ISO/TS 10303-1259:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1259: Application module: Activity as realized","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1259:2010-03 specifies the application module for\n         Activity as realized. The following are within the scope of \n         ISO/TS 10303-1259:2010-03: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","objectID":"56237_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>9: Application module: Activity as realized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2010-03 specifies the application module for\n         Activity as realized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>9:2010-03: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52643","uuid":"21de7b2c-11d2-45b8-b81b-e2f36f468e97","title":"ISO/TS 10303-1256:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1256: Application module: State observed","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1256:2010-03 specifies the application module for\n         State observed. The following are within the scope of \n         ISO/TS 10303-1256:2010-03: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","objectID":"52643_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>6: Application module: State observed","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2010-03 specifies the application module for\n         State observed. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>6:2010-03: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38989","uuid":"372320af-1ae4-4c67-9e1e-c517e23bb586","title":"ISO/TS 10303-1253:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Withdrawn","year":2018,"order":100,"text":"ISO/TS 10303-1253:2004 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2004: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"38989_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2004 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2004: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/84/38465","uuid":"d0952d61-2c24-4727-a89c-f30f71d5e8ab","title":"ISO/TS 10303-1250:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1250: Application module: Attachment slot","status":"Withdrawn","year":2018,"order":100,"text":"ISO/TS 10303-1250:2004 specifies the application module for\n         Attachment slot. The following are within the scope of \n         ISO/TS 10303-1250:2004: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","objectID":"38465_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>0: Application module: Attachment slot","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2004 specifies the application module for\n         Attachment slot. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>0:2004: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/63/56356","uuid":"de7b6ddd-b003-46b0-8f49-fe5a7200f7fd","title":"ISO/TS 10303-1258:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1258:2010-03 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2010-03: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"56356_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2010-03 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2010-03: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/63/56335","uuid":"52a58cc2-156a-456d-be35-d7f082c01963","title":"ISO/TS 10303-1251:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1251:2010-03 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2010-03: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"56335_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2010-03 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2010-03: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52642","uuid":"9acd39cc-64bb-4fd1-8e68-5a9c6cf25e65","title":"ISO/TS 10303-1255:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1255: Application module: State definition","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1255:2010-03 specifies the application module for\n         State definition. The following are within the scope of \n         ISO/TS 10303-1255:2010-03: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","objectID":"52642_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>5: Application module: State definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2010-03 specifies the application module for\n         State definition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>5:2010-03: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39332","uuid":"711221b9-9d69-47b1-9359-9d60ff8f8e50","title":"ISO/TS 10303-1258:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1258:2004 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2004: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"39332_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2004 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2004: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39330","uuid":"4eb4b214-e041-4e49-9394-dc1d2e2b8e9d","title":"ISO/TS 10303-1252:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1252: Application module: Probability","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1252:2004 specifies the application module for\n         Probability. The following are within the scope of \n         ISO/TS 10303-1252:2004: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","objectID":"39330_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>2: Application module: Probability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2004 specifies the application module for\n         Probability. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>2:2004: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39309","uuid":"f36e2d73-8d8a-41f4-ace5-9b27ae4b597c","title":"ISO/TS 10303-1259:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1259: Application module: Activity as realized","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1259:2004 specifies the application module for\n         Activity as realized. The following are within the scope of \n         ISO/TS 10303-1259:2004: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","objectID":"39309_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>9: Application module: Activity as realized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2004 specifies the application module for\n         Activity as realized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>9:2004: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38988","uuid":"6e01b94b-a0dd-4fc1-b5e6-ef3aac71e901","title":"ISO/TS 10303-1256:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1256: Application module: State observed","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1256:2004 specifies the application module for\n         State observed. The following are within the scope of \n         ISO/TS 10303-1256:2004: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","objectID":"38988_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>6: Application module: State observed","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2004 specifies the application module for\n         State observed. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>6:2004: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38987","uuid":"a81eb924-2fef-4327-a5b2-685a5a763592","title":"ISO/TS 10303-1255:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1255: Application module: State definition","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1255:2004 specifies the application module for\n         State definition. The following are within the scope of \n         ISO/TS 10303-1255:2004: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","objectID":"38987_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>5: Application module: State definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2004 specifies the application module for\n         State definition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>5:2004: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/84/38466","uuid":"4dd49461-d9fd-44e8-84e0-81bf63192579","title":"ISO/TS 10303-1251:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1251:2004 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2004: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product\n            with which one or more other products or the environment will interact. ","objectID":"38466_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2004 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2004: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product\n            with which one or more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}}],"nbHits":193,"page":0,"nbPages":2,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 125","params":"query=ISO+125&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":2}
61
+ http_version:
62
+ recorded_at: Sat, 09 Oct 2021 16:54:04 GMT
63
+ - request:
64
+ method: get
65
+ uri: https://www.iso.org/contents/data/standard/07/28/72849.html
66
+ body:
67
+ encoding: US-ASCII
68
+ string: ''
69
+ headers:
70
+ Accept-Encoding:
71
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
72
+ Accept:
73
+ - "*/*"
74
+ User-Agent:
75
+ - Ruby
76
+ Host:
77
+ - www.iso.org
78
+ response:
79
+ status:
80
+ code: 301
81
+ message: ''
82
+ headers:
83
+ Expires:
84
+ - Wed, 09 May 1979 05:30:00 GMT
85
+ Cache-Control:
86
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
87
+ Pragma:
88
+ - no-cache
89
+ Set-Cookie:
90
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
91
+ Secure
92
+ - JSESSIONID=DEB35E8763070B21D55CA2CA15C244A8; Path=/; Secure; HttpOnly
93
+ Location:
94
+ - "/standard/72849.html"
95
+ Content-Length:
96
+ - '0'
97
+ Date:
98
+ - Sat, 09 Oct 2021 16:54:06 GMT
99
+ Strict-Transport-Security:
100
+ - max-age=31536000; includeSubDomains
101
+ body:
102
+ encoding: UTF-8
103
+ string: ''
104
+ http_version:
105
+ recorded_at: Sat, 09 Oct 2021 16:54:07 GMT
106
+ - request:
107
+ method: get
108
+ uri: https://www.iso.org/standard/72849.html
109
+ body:
110
+ encoding: US-ASCII
111
+ string: ''
112
+ headers:
113
+ Accept-Encoding:
114
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
115
+ Accept:
116
+ - "*/*"
117
+ User-Agent:
118
+ - Ruby
119
+ Host:
120
+ - www.iso.org
121
+ response:
122
+ status:
123
+ code: 200
124
+ message: ''
125
+ headers:
126
+ Expires:
127
+ - Wed, 09 May 1979 05:30:00 GMT
128
+ Cache-Control:
129
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
130
+ Pragma:
131
+ - no-cache
132
+ Set-Cookie:
133
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
134
+ Secure
135
+ - JSESSIONID=174BFA5EF2E419DDEF1D30B00F39C57D; Path=/; Secure; HttpOnly
136
+ Vary:
137
+ - accept-encoding
138
+ Content-Type:
139
+ - text/html;charset=UTF-8
140
+ Transfer-Encoding:
141
+ - chunked
142
+ Date:
143
+ - Sat, 09 Oct 2021 16:54:08 GMT
144
+ Strict-Transport-Security:
145
+ - max-age=31536000; includeSubDomains
146
+ body:
147
+ encoding: ASCII-8BIT
148
+ string: !binary |-
149
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 125:2020 - Natural rubber latex concentrate — Determination of alkalinity</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/72849.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20200219" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/07/28/72849.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 125:2020" />
    <meta property="og:title" content="ISO 125:2020" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Natural rubber latex concentrate — Determination of alkalinity" />
    <meta property="og:description" content="Natural rubber latex concentrate — Determination of alkalinity" />
    <meta name="description" content="Natural rubber latex concentrate — Determination of alkalinity" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/72849.html">français</a></li><li><a href="/ru/standard/72849.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="72849 - ISO 125:2020 - Natural rubber latex concentrate — Determination of alkalinity"></span>

  <span class="hidden" id="itemReference">ISO 125:2020</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">72849</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/83.html">83</a> >&nbsp;<a href="/en/ics/83.040.html">83.040</a> >&nbsp;<a href="/en/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 125:2020</h1>
  <h2 class="no-uppercase">Natural rubber latex concentrate — Determination of alkalinity</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:72849:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate.</p>
<p>The method is not necessarily suitable for latices from natural sources other than <i>Hevea brasiliensis</i> or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber.</p>
<p>NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in ISO 13773.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/07/28/72849.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2020-02</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 7
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Raw materials (including latex) for use in the rubber industry</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex and raw rubber</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following  <a href="/sdgs.html">Sustainable Development Goals</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG12.html" title="Responsible Consumption and Production">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Responsible Consumption and Production</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/sdg/SDG09.html" title="Industry, Innovation and Infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industry, Innovation and Infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dWmQAI~a0c0X00000OsDjTQAV" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dXVQAY~a0c0X00000OsDkCQAV" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFl7AAE~a0c0X00000OqPNqQAN" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFnMAAU~a0c0X00000OqPObQAN" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/59265.html">ISO 125:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 125:2020</h5>
                  
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>60.60</strong><span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2016-12-06</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2017-03-06</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2017-03-07</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2017-06-08</span>
                              <div class="stage-title">
                                Close of voting/ comment period
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2018-12-03</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2018-12-04</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2019-02-05</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2019-05-01</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2019-12-10</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2020-02-19</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard proposed by TC or SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/83.html">83</a></li>
    
      <li><a href="/en/ics/83.040.html">83.040</a></li>
    
      <li><a href="/en/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 125:2020</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
150
+ http_version:
151
+ recorded_at: Sat, 09 Oct 2021 16:54:10 GMT
152
+ - request:
153
+ method: get
154
+ uri: https://www.iso.org/fr/standard/72849.html
155
+ body:
156
+ encoding: US-ASCII
157
+ string: ''
158
+ headers:
159
+ Accept-Encoding:
160
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
161
+ Accept:
162
+ - "*/*"
163
+ User-Agent:
164
+ - Ruby
165
+ Host:
166
+ - www.iso.org
167
+ response:
168
+ status:
169
+ code: 200
170
+ message: ''
171
+ headers:
172
+ Expires:
173
+ - Wed, 09 May 1979 05:30:00 GMT
174
+ Cache-Control:
175
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
176
+ Pragma:
177
+ - no-cache
178
+ Set-Cookie:
179
+ - BIGipServerpool_prod_iso_www-jahia=713576842.36895.0000; path=/; Httponly;
180
+ Secure
181
+ - JSESSIONID=208106C745C80F38221FFD710CD2BEDC; Path=/; Secure; HttpOnly
182
+ Vary:
183
+ - accept-encoding
184
+ Content-Type:
185
+ - text/html;charset=UTF-8
186
+ Transfer-Encoding:
187
+ - chunked
188
+ Date:
189
+ - Sat, 09 Oct 2021 16:54:11 GMT
190
+ Strict-Transport-Security:
191
+ - max-age=31536000; includeSubDomains
192
+ body:
193
+ encoding: ASCII-8BIT
194
+ string: !binary |-
195
+ <!DOCTYPE html>


<html lang="fr">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'fr'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 125:2020 - Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/fr/standard/72849.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"fr",uilang:"fr",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='fr_FR';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20200219" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/07/28/72849.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 125:2020" />
    <meta property="og:title" content="ISO 125:2020" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
    <meta property="og:description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
    <meta name="description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Passer au contenu principal</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/standards.html" class="dropdown-toggle" role="button">Normes</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html" class="dropdown-toggle" role="button">Avantages</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-and-smes.html" class="dropdown-toggle" role="button">PME</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-consumers.html" class="dropdown-toggle" role="button">Consommateurs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-policy-makers.html" class="dropdown-toggle" role="button">L’ISO et les organismes de réglementation</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/standards-in-action.html" class="dropdown-toggle" role="button">Normes en action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html" class="dropdown-toggle" role="button">Les normes les plus connues</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformité</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/the-iso-survey.html" class="dropdown-toggle" role="button">L'Étude ISO</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html" class="dropdown-toggle" role="button">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/about-us.html" class="dropdown-toggle" role="button">À propos de l'ISO</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/what-we-do.html" class="dropdown-toggle" role="button">Nos activités</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/developing-standards.html"  class="dropdown-toggle" role="button">Elaboration des normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/research-and-education.html" class="dropdown-toggle" role="button">Recherche</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/capacity-building.html" class="dropdown-toggle" role="button">Renforcement des capacités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/education-about-standards.html" class="dropdown-toggle" role="button">Enseignement sur les normes</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html" class="dropdown-toggle" role="button">Membres</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/announcements.html" class="dropdown-toggle" role="button">Communiqués</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/fr/strategy2030.html" class="dropdown-toggle" role="button">Stratégie 2030</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Facteurs de changement</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Nos objectifs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Mesurer le succès</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/news.html" class="dropdown-toggle" role="button">Actualités</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html" class="dropdown-toggle" role="button">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html" class="dropdown-toggle" role="button">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/developing-standards.html" class="dropdown-toggle" role="button">Participer</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html" class="dropdown-toggle" role="button">Qui élabore les normes</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/technical-committees.html" class="dropdown-toggle" role="button">Comités techniques</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Autres organismes</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organisations en coopération</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html" class="dropdown-toggle" role="button">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html" class="dropdown-toggle" role="button">Pourquoi s’engager ?</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/fr/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html" class="dropdown-toggle" role="button">Publications et produits</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/fr/#account/products"  target="_blank" class="dropdown-toggle" role="button">Mon compte</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/fr/home.html" title="Organisation internationale de normalisation" alt="Logo ISO"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/fr"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Recherche</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=fr" title="Panier d'achat" aria-label="Panier d'achat">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">FR <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/standard/72849.html">English</a></li><li><a href="/ru/standard/72849.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/news.html">Actualités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="72849 - ISO 125:2020 - Latex concentré de caoutchouc naturel — Détermination de l'alcalinité"></span>

  <span class="hidden" id="itemReference">ISO 125:2020</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">72849</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="Organisation internationale de normalisation">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/fr/standards-catalogue/browse-by-ics.html"title="Explorez la collection de normes ISO dans son intégralité et trouvez celles qui s’appliquent à votre secteur.">ICS</a> >&nbsp;<a href="/fr/ics/83.html">83</a> >&nbsp;<a href="/fr/ics/83.040.html">83.040</a> >&nbsp;<a href="/fr/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 125:2020</h1>
  <h2 class="no-uppercase">Latex concentré de caoutchouc naturel — Détermination de l'alcalinité</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Acheter cette norme
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Résumé&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:72849:fr">Prévisualiser</a></h3>
          <div itemprop="description">
            <p><p>Le présent document spécifie une méthode de détermination de l'alcalinité du latex concentré de caoutchouc naturel.</p>
<p>La méthode ne convient pas nécessairement aux latex d'origine naturelle autres que l'<i>Hevea brasiliensis</i> ou aux latex de caoutchouc de synthèse, aux latex formulés, aux latex vulcanisés ou aux dispersions artificielles de caoutchouc.</p>
<p>NOTE       Une méthode de détermination de l'alcalinité du latex de polychloroprène est spécifiée dans l'ISO 13773.</p></p>
          </div>
          <br/>
        <h3>
  Informations générales
  <sup><a href="/fr/contents/data/standard/07/28/72849.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="S'abonner&nbsp;aux&nbsp;mises&nbsp;à&nbsp;jour">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>État actuel&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Publiée"></span>Publiée</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Date de publication&nbsp;: </strong><span itemprop="releaseDate">2020-02</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Nombre de pages&nbsp;:</strong> 7
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Comité technique</div> :
        <div class="entry-name entry-block">
          <a href="/fr/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Matières premières (y compris le latex) à l'usage de l'industrie des élastomères</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/fr/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex et caoutchouc brut</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/fr/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Objectifs de développement durable" />
      </p>
      <p>
        Cette norme contribue aux  <a href="/fr/sdgs.html">Objectifs de développement durable</a>&nbsp;suivants&nbsp;:
      <p>
      <div class="clearfix">
        
          <a href="/fr/sdg/SDG12.html" title="Consommation et production responsables">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Consommation et production responsables</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/fr/sdg/SDG09.html" title="Industrie, innovation et infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industrie, innovation et infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Acheter&nbsp;cette norme</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">fr</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Langue</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dWmQAI~a0c0X00000OsDjTQAV" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dXVQAY~a0c0X00000OsDkCQAV" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Papier
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFl7AAE~a0c0X00000OqPNqQAN" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFnMAAU~a0c0X00000OqPObQAN" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'fr', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Acheter
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Valider mon panier"></span>
            <span id="continueShopping" class="hidden" data-label="Ajouter au panier et continuer mes achats"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Cycle de vie</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Précédemment</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Annulée</div>
                    <h5><a href="/fr/standard/59265.html">ISO 125:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Actuellement</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Publiée</div>
                    
              <h5>ISO 125:2020</h5>
                  
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stade: <strong>60.60</strong><span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Préliminaire</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposition</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2016-12-06</span>
                              <div class="stage-title">
                                Nouveau projet approuvé
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Préparation</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Comité</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2017-03-06</span>
                              <div class="stage-title">
                                Projet de comité (CD) enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2017-03-07</span>
                              <div class="stage-title">
                                Mise à l'étude/au vote du CD
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2017-06-08</span>
                              <div class="stage-title">
                                Clôture du vote/ de la période des observations
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2018-12-03</span>
                              <div class="stage-title">
                                CD approuvé pour enregistrement comme DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquête</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2018-12-04</span>
                              <div class="stage-title">
                                DIS enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2019-02-05</span>
                              <div class="stage-title">
                                Mise au vote du DIS:  12 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2019-05-01</span>
                              <div class="stage-title">
                                Clôture du vote
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Rapport complet diffusé: DIS approuvé pour enregistrement comme FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approbation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Texte final reçu ou FDIS enregistré pour approbation formelle
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2019-12-10</span>
                              <div class="stage-title">
                                Epreuve envoyée au secrétariat ou mise au vote du FDIS: 8 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Clôture du vote Epreuve retournée par le secrétariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Norme internationale en cours de publication
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/fr/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2020-02-19</span>
                              <div class="stage-title">
                                Norme internationale publiée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Examen</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale à réviser
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale proposée par le TC ou SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Annulation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Vous avez une question?</h4>

<p>Consulter notre&nbsp;<a href="/fr/frequently-asked-questions-faqs.html" title="Foire Aux Questions (FAQs)">FAQ</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Service &agrave; la client&egrave;le</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Horaires d&rsquo;ouverture:<br />
De lundi &agrave; vendredi - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Suivez l&#39;actualit&eacute; de l&#39;ISO</h4>

<p>Inscrivez-vous &agrave; notre Newsletter (en anglais) pour suivre nos actualit&eacute;s, points de vue et informations sur nos produits.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/fr/home.html" title="Page d'accueil"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/fr/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a>

        </li>
      
        <li>
          
              <a href="/fr/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/fr/ics/83.html">83</a></li>
    
      <li><a href="/fr/ics/83.040.html">83.040</a></li>
    
      <li><a href="/fr/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 125:2020</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Plan du site</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html">Avantages</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html">Les normes les plus connues</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/conformity-assessment.html">Certification & conformité</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/what-we-do.html">Nos activités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html">Membres</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030.html">Stratégie 2030</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/news.html">Actualités</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html">Qui élabore les normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html">Pourquoi s’engager ?</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html">Publications et produits</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-name-and-logo.html">Nom et logo de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/privacy-and-copyright.html">Confidentialité et droit d'auteur</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/working-with-iso.html" >Emploi</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/frequently-asked-questions-faqs.html">FAQ</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/contact-iso.html">Contacter l'ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Le monde va loin quand il s'accorde</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">Nous nous engageons à ce que notre site Web soit accessible à tous. Pour toute question ou suggestion concernant l'accessibilité du site, <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contactez-nous</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© Tous droits réservés</a> <span id="copyright" class="collapse">Le matériel publié sur ISO.org est sujet aux mêmes conditions en matière de droits d’auteur que les publications de l’ISO et son emploi est conditionné par l’acceptation, par l’utilisateur, des conditions de l’ISO en matière de droits d’auteur régissant les publications de l’ISO. Toute utilisation du matériel concerné, y compris sa reproduction intégrale ou partielle vers un autre site Internet, requiert l’autorisation écrite de l’ISO. Toute demande à cet effet doit être adressée à <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Retour en haut de page"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression" /></div>
            <div class="poweredby-txt">Développé par</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
196
+ http_version:
197
+ recorded_at: Sat, 09 Oct 2021 16:54:12 GMT
198
+ - request:
199
+ method: post
200
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
201
+ body:
202
+ encoding: UTF-8
203
+ string: '{"query":"ISO 126","hitsPerPage":100,"filters":"category:standard"}'
204
+ headers:
205
+ User-Agent:
206
+ - Algolia for Ruby (2.1.1), Ruby (2.7.2)
207
+ X-Algolia-Api-Key:
208
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
209
+ X-Algolia-Application-Id:
210
+ - JCL49WV5AR
211
+ Content-Type:
212
+ - application/json; charset=utf-8
213
+ Accept-Encoding:
214
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
215
+ Accept:
216
+ - "*/*"
217
+ Connection:
218
+ - keep-alive
219
+ Keep-Alive:
220
+ - '30'
221
+ response:
222
+ status:
223
+ code: 200
224
+ message: OK
225
+ headers:
226
+ Server:
227
+ - nginx
228
+ Date:
229
+ - Sat, 09 Oct 2021 16:54:13 GMT
230
+ Content-Type:
231
+ - application/json; charset=UTF-8
232
+ Transfer-Encoding:
233
+ - chunked
234
+ Connection:
235
+ - keep-alive
236
+ X-Alg-Pt:
237
+ - '2'
238
+ Accept-Encoding:
239
+ - deflate, gzip
240
+ Cache-Control:
241
+ - no-store
242
+ Access-Control-Allow-Origin:
243
+ - "*"
244
+ Timing-Allow-Origin:
245
+ - "*"
246
+ X-Content-Type-Options:
247
+ - nosniff
248
+ Strict-Transport-Security:
249
+ - max-age=31536000; includeSubDomains; preload
250
+ Content-Disposition:
251
+ - inline; filename=a.txt
252
+ body:
253
+ encoding: ASCII-8BIT
254
+ string: !binary |-
255
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/51/35176","uuid":"f730d72f-d02c-49ce-b066-c2cb95e56d5d","title":"ISO 126:2005 Natural rubber latex concentrate — Determination of dry rubber content","status":"Published","year":2018,"order":11,"text":"ISO 126:2005 specifies a method for the determination of the dry rubber content of natural rubber latex concentrate. The method is not necessarily suitable for latices preserved with potassium hydroxide, latices from natural sources other than Hevea brasiliensis , or for compounded latex, vulcanized latex or artificial dispersions of rubber and it is not applicable to synthetic rubber latices. ","objectID":"35176_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>:2005 Natural rubber latex concentrate — Determination of dry rubber content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>:2005 specifies a method for the determination of the dry rubber content of natural rubber latex concentrate. The method is not necessarily suitable for latices preserved with potassium hydroxide, latices from natural sources other than Hevea brasiliensis , or for compounded latex, vulcanized latex or artificial dispersions of rubber and it is not applicable to synthetic rubber latices. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/55/25530","uuid":"31a762e0-c8fc-445f-9802-24f0e12616ab","title":"ISO 126:1995 Latex, rubber, natural concentrate — Determination of dry rubber content","status":"Withdrawn","year":2005,"order":100,"text":"Gives a method for the determination of the dry rubber content of natural rubber latex concentrate. Replaces the third edition which has been insignificantly revised. ","objectID":"25530_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>:1995 Latex, rubber, natural concentrate — Determination of dry rubber content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"Gives a method for the determination of the dry rubber content of natural rubber latex concentrate. Replaces the third edition which has been insignificantly revised. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3933","uuid":"9ad47412-a7a4-4648-b710-38ae339238e3","title":"ISO 126:1989 Natural rubber latex concentrate — Determination of dry rubber content","status":"Withdrawn","year":1995,"order":100,"objectID":"3933_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>:1989 Natural rubber latex concentrate — Determination of dry rubber content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/08/20885","uuid":"f8da5cb6-3405-4d4c-82ad-506c1bd9593f","title":"ISO 126:1989/Cor 1:1992 Natural rubber latex concentrate — Determination of dry rubber content — Technical Corrigendum 1","status":"Withdrawn","year":1995,"order":100,"objectID":"20885_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>:1989/Cor 1:1992 Natural rubber latex concentrate — Determination of dry rubber content — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3932","uuid":"2f0282d5-ab35-4a48-9758-459e72782a38","title":"ISO 126:1982 Rubber latex, natural — Determination of dry rubber content","status":"Withdrawn","year":1989,"order":100,"objectID":"3932_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>:1982 Rubber latex, natural — Determination of dry rubber content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/03/80326","uuid":"d07f33e6-b7fd-443e-8e57-44c963870528","title":"ISO 12625-7:2021 Tissue paper and tissue products — Part 7: Determination of optical properties — Measurement of brightness and colour with D65/10° (outdoor daylight)","status":"Published","year":2021,"order":11,"text":"This document specifies testing procedures for the instrumental determination of brightness and colour of tissue paper and tissue products viewed under outdoor daylight conditions. It also gives specific instructions for the preparation of test pieces (single-ply, multi-ply products) and for the optical measurements of products, where special precautions can be necessary. NOTE       The properties called ISO brightness and colour with C/2° (indoor daylight) are measured with an instrument adjusted to a much lower UV content than that specified in this document. The measurements of ISO brightness and colour with C/2° (indoor daylight) are described in ISO 12625-15. ","objectID":"80326_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-7:2021 Tissue paper and tissue products — Part 7: Determination of optical properties — Measurement of brightness and colour with D65/10° (outdoor daylight)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies testing procedures for the instrumental determination of brightness and colour of tissue paper and tissue products viewed under outdoor daylight conditions. It also gives specific instructions for the preparation of test pieces (single-ply, multi-ply products) and for the optical measurements of products, where special precautions can be necessary. NOTE       The properties called <em>ISO</em> brightness and colour with C/2° (indoor daylight) are measured with an instrument adjusted to a much lower UV content than that specified in this document. The measurements of <em>ISO</em> brightness and colour with C/2° (indoor daylight) are described in <em>ISO</em> <em>126</em>25-15. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/00/80069","uuid":"ced50350-c730-423a-a71f-a62b74f0b45a","title":"ISO 12635:2021 Graphic technology — Plates for offset printing — Dimensions","status":"Published","year":2021,"order":11,"text":"This document specifies the width, length and thickness of metal lithographic printing plates (referred to hereafter as “plates”). For plates to be used in computer to plate (CtP) applications, flatness, edge straightness and burr requirements are also included. These requirements are applicable to unprocessed plates. ","objectID":"80069_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>35:2021 Graphic technology — Plates for offset printing — Dimensions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies the width, length and thickness of metal lithographic printing plates (referred to hereafter as “plates”). For plates to be used in computer to plate (CtP) applications, flatness, edge straightness and burr requirements are also included. These requirements are applicable to unprocessed plates. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/91/79152","uuid":"4bbf39f2-aa05-4f2e-b571-3091e7521a8a","title":"ISO 12642-3:2021 Graphic technology — Input data for characterization of 4-colour process printing — Part 3: Extended data set including near neutral scale","status":"Published","year":2021,"order":11,"text":"This document defines a data set of ink value combinations that can be used to characterize four-colour process printing. This data set is not optimized for any printing process or application area but is robust enough for all general applications. While it is primarily aimed at process colour printing with CMYK inks, it can also be used with any combination of three chromatic inks and a dark ink. This document is an alternative to the ISO 12642‑2 data set where more neutral scale data are desired. It is not designed as a replacement for ISO 12642-2. ","objectID":"79152_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>42-3:2021 Graphic technology — Input data for characterization of 4-colour process printing — Part 3: Extended data set including near neutral scale","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document defines a data set of ink value combinations that can be used to characterize four-colour process printing. This data set is not optimized for any printing process or application area but is robust enough for all general applications. While it is primarily aimed at process colour printing with CMYK inks, it can also be used with any combination of three chromatic inks and a dark ink. This document is an alternative to the <em>ISO</em> <em>126</em>42‑2 data set where more neutral scale data are desired. It is not designed as a replacement for <em>ISO</em> <em>126</em>42-2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77675","uuid":"53eb2d2d-bed0-4986-93fe-e3197b9a9fda","title":"ISO 12614-19:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 19: Automatic valve","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the automatic valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is applicable to vehicles using natural gas in accordance with ISO 15403-1 (mono-fuel, bi-fuel or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77675_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-19:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 19: Automatic valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the automatic valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is applicable to vehicles using natural gas in accordance with <em>ISO</em> 15403-1 (mono-fuel, bi-fuel or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77674","uuid":"8fd62dac-2c80-4577-b7e5-8b1bcaed0fe6","title":"ISO 12614-18:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 18: Gas temperature sensor","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the gas temperature sensor, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77674_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-18:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 18: Gas temperature sensor","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the gas temperature sensor, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77673","uuid":"ed7fea8f-0895-4b89-9061-1d46105daf3a","title":"ISO 12614-17:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 17: Natural gas detector","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the natural gas detector, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 Mpa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77673_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-17:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 17: Natural gas detector","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the natural gas detector, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 Mpa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77672","uuid":"9f70f549-5965-4a95-8615-5a2e0d52aca9","title":"ISO 12614-16:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 16: Heat exchanger-vaporizer","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the heat exchanger-vaporizer, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77672_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-16:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 16: Heat exchanger-vaporizer","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the heat exchanger-vaporizer, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77671","uuid":"6c58a1a0-fa90-404f-95b5-e75054022d39","title":"ISO 12614-15:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 15: Capacitance fuel content gauge","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the capacitance fuel content gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833.This document is applicable to vehicles using natural gas in accordance with ISO 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1N/mm 2 . ","objectID":"77671_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-15:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 15: Capacitance fuel content gauge","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the capacitance fuel content gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833.This document is applicable to vehicles using natural gas in accordance with <em>ISO</em> 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77670","uuid":"74b1b6be-c556-4e5d-9d68-387ac31682a6","title":"ISO 12614-14:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 14: Differential pressure fuel content gauge","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the differential pressure fuel content gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a maximum working pressure for natural gas as fuel of 1,6 MPa (16 bar 1 ).  Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77670_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-14:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 14: Differential pressure fuel content gauge","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the differential pressure fuel content gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a maximum working pressure for natural gas as fuel of 1,6 MPa (16 bar 1 ).  Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77669","uuid":"0aa16880-71ea-4836-8d10-c199f47e05f7","title":"ISO 12614-13:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 13: Tank pressure control regulator","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the tank pressure control regulator, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77669_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-13:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 13: Tank pressure control regulator","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the tank pressure control regulator, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77668","uuid":"2540d469-d867-4eea-ae13-39add2389648","title":"ISO 12614-12:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 12: Rigid fuel line in copper and its alloys","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the rigid fuel line in copper and its alloys, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77668_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-12:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 12: Rigid fuel line in copper and its alloys","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the rigid fuel line in copper and its alloys, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77667","uuid":"a0bba208-44bf-47fb-8f11-705a656bd1fc","title":"ISO 12614-11:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 11: Fittings","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the fittings, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77667_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-11:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 11: Fittings","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the fittings, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77666","uuid":"37c52878-1b23-4d6e-9fde-7d96765deca4","title":"ISO 12614-10:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 10: Rigid fuel line in stainless steel","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the rigid fuel line, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77666_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-10:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 10: Rigid fuel line in stainless steel","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the rigid fuel line, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77665","uuid":"aeaebeef-ab5e-43ea-b418-e5422c8f7f5e","title":"ISO 12614-9:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 9: Gas-tight housing and ventilation hose","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the gas-tight housing and ventilation hose, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is applicable to vehicles using natural gas in accordance with ISO 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77665_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-9:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 9: Gas-tight housing and ventilation hose","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the gas-tight housing and ventilation hose, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is applicable to vehicles using natural gas in accordance with <em>ISO</em> 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77664","uuid":"6e915b3e-c77d-4fdb-94f2-be3e4b108ed7","title":"ISO 12614-8:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 8: Excess flow valve","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the excess flow valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is applicable to vehicles using natural gas in accordance with ISO 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77664_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-8:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 8: Excess flow valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the excess flow valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is applicable to vehicles using natural gas in accordance with <em>ISO</em> 15403-1 (mono-fuel, bi-fuel, or dual-fuel applications). It is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77663","uuid":"568a33e2-e291-4959-ae05-cd6d0d01eb57","title":"ISO 12614-7:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 7: Pressure relief valve (PRV)","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the pressure relief valve (PRV), a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77663_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-7:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 7: Pressure relief valve (PRV)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the pressure relief valve (PRV), a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77661","uuid":"21436e84-c239-44a4-84e0-a05ffe89edb5","title":"ISO 12614-5:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 5: Tank pressure gauge","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the tank pressure gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77661_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-5:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 5: Tank pressure gauge","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the tank pressure gauge, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77660","uuid":"5a7268ed-c1ef-4699-a0e0-b8192f19e453","title":"ISO 12614-4:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 4: Manual valve","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the manual valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77660_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-4:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 4: Manual valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the manual valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa (16 bar 1 ). Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77659","uuid":"734133ce-1d56-4fa4-80b3-53a4cbdef64b","title":"ISO 12614-3:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 3: Check valve","status":"Published","year":2021,"order":11,"text":"This document specifies tests and requirements for the check valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in ISO 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77659_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-3:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 3: Check valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies tests and requirements for the check valve, a liquefied natural gas fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as a fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77658","uuid":"9cd47847-1912-43b3-8555-ff4860be62be","title":"ISO 12614-2:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 2: Performance and general test methods","status":"Published","year":2021,"order":11,"text":"This document specifies the performance and general test methods of liquefied natural gas fuel system components, intended for use on the types of motor vehicles as defined in ISO 3833. This document is also applicable to other LNG-fueled motor vehicles as far as appropriate, until any specific norm is worked out for such a type of vehicle. It also provides general design principles and specifies requirements for instructions and marking. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document  is based upon a working pressure for natural gas as fuel of 1,6 MPa (16 bar) 1 . Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","objectID":"77658_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-2:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 2: Performance and general test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies the performance and general test methods of liquefied natural gas fuel system components, intended for use on the types of motor vehicles as defined in <em>ISO</em> 3833. This document is also applicable to other LNG-fueled motor vehicles as far as appropriate, until any specific norm is worked out for such a type of vehicle. It also provides general design principles and specifies requirements for instructions and marking. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) refuelling receptacles. It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document  is based upon a working pressure for natural gas as fuel of 1,6 MPa (16 bar) 1 . Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 . ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77657","uuid":"764dc7d1-47a8-44ec-bcb5-37fc70cdcb26","title":"ISO 12614-1:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 1: General requirements and definitions","status":"Published","year":2021,"order":11,"text":"This document specifies general requirements and definitions of liquefied natural gas fuel system components, intended for use on the types of motor vehicles as defined in ISO 3833. It also provides general design principles and specifies requirements for instructions and marking. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) fuelling receptacles. It is recognized that miscellaneous components, not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm2. ","objectID":"77657_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>14-1:2021 Road vehicles — Liquefied natural gas (LNG) fuel system components — Part 1: General requirements and definitions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies general requirements and definitions of liquefied natural gas fuel system components, intended for use on the types of motor vehicles as defined in <em>ISO</em> 3833. It also provides general design principles and specifies requirements for instructions and marking. This document is not applicable to the following: a) fuel containers; b) stationary gas engines; c) container mounting hardware; d) electronic fuel management; e) fuelling receptacles. It is recognized that miscellaneous components, not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. All references to pressure in this document are to be considered gauge pressures unless otherwise specified. This document is based upon a working pressure for natural gas as fuel of 1,6 MPa [16 bar 1 ]. Other working pressures can be accommodated by adjusting the pressure by the appropriate factor (ratio). For example, a 2 MPa (20 bar) working pressure system will require pressures to be multiplied by 1,25.   1 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm2. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/71/77104","uuid":"a5f9e8bc-b5ad-44f4-b598-ffc1e662ad41","title":"ISO 12647-8:2021 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 8: Validation print processes working directly from digital data","status":"Published","year":2021,"order":11,"text":"This document specifies requirements that can be used for determining the conformance of systems that produce a hard-copy validation print, directly from digital data, which is intended to simulate the expected appearance of material printed in accordance with a characterized printing condition. It is not intended for use in determining the conformance of production printing systems (digital or conventional) since many aspects of production printing are not covered in this document. ","objectID":"77104_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-8:2021 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 8: Validation print processes working directly from digital data","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies requirements that can be used for determining the conformance of systems that produce a hard-copy validation print, directly from digital data, which is intended to simulate the expected appearance of material printed in accordance with a characterized printing condition. It is not intended for use in determining the conformance of production printing systems (digital or conventional) since many aspects of production printing are not covered in this document. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75428","uuid":"f2d682a0-cbc9-4561-aeca-6305e48b869c","title":"ISO 12671:2021 Thermal spraying — Thermally sprayed coatings — Symbolic representation on drawings","status":"Published","year":2021,"order":11,"text":"This document specifies how the symbolic representation of thermally sprayed coatings is indicated on drawings. ","objectID":"75428_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>71:2021 Thermal spraying — Thermally sprayed coatings — Symbolic representation on drawings","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies how the symbolic representation of thermally sprayed coatings is indicated on drawings. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/43/74360","uuid":"72576946-f194-4638-a3df-1326fba34519","title":"ISO 12647-9:2021 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 9: Metal decoration printing processes using offset lithography","status":"Published","year":2021,"order":11,"text":"This document specifies requirements for systems that are used to produce offset prints for process colour reproduction on metallic substrates, which have been printed with a white coating. It is intended for flat printed sheet metal applications. It does not cover shaped or pre-formed metal such as pre-formed cans. Recommendations are provided with regard to appropriate test methods associated with these requirements. This document differs from the method used to produce an offset print on paper or board in ISO 12647-2 in that it considers the colour values of a typical white coated metal substrate intended for metal decoration, using offset lithography and substrates that are independent of backing colour. ","objectID":"74360_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-9:2021 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 9: Metal decoration printing processes using offset lithography","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies requirements for systems that are used to produce offset prints for process colour reproduction on metallic substrates, which have been printed with a white coating. It is intended for flat printed sheet metal applications. It does not cover shaped or pre-formed metal such as pre-formed cans. Recommendations are provided with regard to appropriate test methods associated with these requirements. This document differs from the method used to produce an offset print on paper or board in <em>ISO</em> <em>126</em>47-2 in that it considers the colour values of a typical white coated metal substrate intended for metal decoration, using offset lithography and substrates that are independent of backing colour. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/23/72308","uuid":"13856ec0-ed6d-4612-a39b-4e19e4ec7562","title":"ISO 12616-1:2021 Terminology work in support of multilingual communication — Part 1: Fundamentals of translation-oriented terminography","status":"Published","year":2021,"order":11,"text":"This document specifies requirements and recommendations related to fundamentals of translation-oriented terminography for producing sound bilingual or multilingual terminology collections. It deals with the main tasks, skills, processes and technologies for translation-oriented terminography practiced by terminology workers who do terminology work in low-complexity settings as part of non-terminological activities. It does not cover terminology management involving sophisticated workflows, a multitude of roles, or advanced terminological skills and competences. ","objectID":"72308_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>16-1:2021 Terminology work in support of multilingual communication — Part 1: Fundamentals of translation-oriented terminography","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies requirements and recommendations related to fundamentals of translation-oriented terminography for producing sound bilingual or multilingual terminology collections. It deals with the main tasks, skills, processes and technologies for translation-oriented terminography practiced by terminology workers who do terminology work in low-complexity settings as part of non-terminological activities. It does not cover terminology management involving sophisticated workflows, a multitude of roles, or advanced terminological skills and competences. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/22/72279","uuid":"75bec376-b886-4f79-b373-e9034256297c","title":"ISO 12625-17:2021 Tissue paper and tissue products — Part 17: Determination of disintegration in water","status":"Published","year":2021,"order":11,"text":"This document specifies a method to assess the disintegration of tissue paper and tissue products when subjected to mechanical agitation in water. ","objectID":"72279_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-17:2021 Tissue paper and tissue products — Part 17: Determination of disintegration in water","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies a method to assess the disintegration of tissue paper and tissue products when subjected to mechanical agitation in water. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/97/69741","uuid":"2f93c8f3-9ea7-4214-87c3-5d2997d7706a","title":"ISO 12612:2016 Cinematography — Interchange of post-production sprocket-based materials","status":"Published","year":2021,"order":11,"text":"ISO 12612:2016 specifies certain parameters and technical characteristics of post-production motion-picture materials used in the international exchange of 35 mm and 70 mm picture and sound elements. ISO 12612:2016 further specifies a method for the evaluation of picture-image quality based on a standardized test image contained in the post-production picture elements. ","objectID":"69741_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>12:2016 Cinematography — Interchange of post-production sprocket-based materials","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>12:2016 specifies certain parameters and technical characteristics of post-production motion-picture materials used in the international exchange of 35 mm and 70 mm picture and sound elements. <em>ISO</em> <em>126</em>12:2016 further specifies a method for the evaluation of picture-image quality based on a standardized test image contained in the post-production picture elements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/88/68807","uuid":"fb0c9b02-952c-4afa-afaf-1a200df06753","title":"ISO 12641-1:2016 Graphic technology — Prepress digital data exchange — Colour targets for input scanner calibration — Part 1: Colour targets for input scanner calibration","status":"Published","year":2021,"order":11,"text":"ISO 12641-1:2016 defines the layout and colorimetric values of targets for use in the calibration of a photographic product/input scanner combination (as used in the preparatory process for printing and publishing). One target is defined for positive colour transparency film and another is defined for colour photographic paper. ","objectID":"68807_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>41-1:2016 Graphic technology — Prepress digital data exchange — Colour targets for input scanner calibration — Part 1: Colour targets for input scanner calibration","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>41-1:2016 defines the layout and colorimetric values of targets for use in the calibration of a photographic product/input scanner combination (as used in the preparatory process for printing and publishing). One target is defined for positive colour transparency film and another is defined for colour photographic paper. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/33/63398","uuid":"619cb94a-b7f9-42ef-8e20-4c4dc53da342","title":"ISO 12625-16:2015 Tissue paper and tissue products — Part 16: Determination of optical properties — Opacity (paper backing) — Diffuse reflectance method","status":"Published","year":2021,"order":11,"text":"ISO 12625-16:2015 specifies the testing procedures for the instrumental determination of the opacity of tissue paper or tissue products by diffuse reflectance using a paper backing. ISO 12625-16:2015 contains specific instructions for the preparation of test pieces of single-ply and multi-ply products, where special preparation/procedures might be necessary. It can be used to determine the opacity of tissue paper and tissue products containing fluorescent whitening agents, provided the UV content of the radiation incident on the test piece has been adjusted to conform to that in the CIE illuminant C using a fluorescent reference standard provided by an authorized laboratory as described in ISO 2470-1. ISO 12625-16:2015 is not applicable to coloured tissue paper and tissue products which incorporate fluorescent dyes or pigments. ","objectID":"63398_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-16:2015 Tissue paper and tissue products — Part 16: Determination of optical properties — Opacity (paper backing) — Diffuse reflectance method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-16:2015 specifies the testing procedures for the instrumental determination of the opacity of tissue paper or tissue products by diffuse reflectance using a paper backing. <em>ISO</em> <em>126</em>25-16:2015 contains specific instructions for the preparation of test pieces of single-ply and multi-ply products, where special preparation/procedures might be necessary. It can be used to determine the opacity of tissue paper and tissue products containing fluorescent whitening agents, provided the UV content of the radiation incident on the test piece has been adjusted to conform to that in the CIE illuminant C using a fluorescent reference standard provided by an authorized laboratory as described in <em>ISO</em> 2470-1. <em>ISO</em> <em>126</em>25-16:2015 is not applicable to coloured tissue paper and tissue products which incorporate fluorescent dyes or pigments. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/33/63393","uuid":"4fe2650d-92ec-461a-b187-ddc4d300c07c","title":"ISO 12625-15:2015 Tissue paper and tissue products — Part 15: Determination of optical properties — Measurement of brightness and colour with C/2° (indoor daylight) illuminant","status":"Published","year":2021,"order":11,"text":"ISO 12625-15:2015 specifies testing procedures for the instrumental determination of brightness and colour of tissue paper and tissue products viewed in indoor daylight conditions. It also gives specific instructions for the preparation of test pieces (single-ply, multi-ply products) and for the optical measurements of products, where special precautions may be necessary. ","objectID":"63393_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-15:2015 Tissue paper and tissue products — Part 15: Determination of optical properties — Measurement of brightness and colour with C/2° (indoor daylight) illuminant","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-15:2015 specifies testing procedures for the instrumental determination of brightness and colour of tissue paper and tissue products viewed in indoor daylight conditions. It also gives specific instructions for the preparation of test pieces (single-ply, multi-ply products) and for the optical measurements of products, where special precautions may be necessary. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/78/57833","uuid":"ad83d439-f829-4846-9248-1d6fa2f67b9b","title":"ISO 12647-2:2013 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 2: Offset lithographic processes","status":"Published","year":2021,"order":11,"text":"ISO 12647-2:2013 specifies a number of process parameters and their values to be applied when producing colour separations, printing formes and print production for four-colour sheet-fed and web-fed offset printing presses excluding coldset offset lithography on newsprint. The parameters and values are chosen in view of the typical process covering the process stages \"colour separation\", \"proof production\", \"making of the printing forme\", \"OK print\" and \"production printing\" on all kinds of commercially available production substrates. ISO 12647-2:2013: is directly applicable to press proof prints and printing processes that use colour separation printing formes as input; is applicable to press proof prints and printing processes with more than four process colours as long as direct analogies to four-colour printing are maintained, such as for data and screening, for print substrates and printing parameters; is applicable to printing on cardboard material for packaging; is applicable for all kinds of drying methods such as heat-set, infrared, and ultraviolet; provides references for quality assurance and quality management. ","objectID":"57833_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-2:2013 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 2: Offset lithographic processes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>47-2:2013 specifies a number of process parameters and their values to be applied when producing colour separations, printing formes and print production for four-colour sheet-fed and web-fed offset printing presses excluding coldset offset lithography on newsprint. The parameters and values are chosen in view of the typical process covering the process stages \"colour separation\", \"proof production\", \"making of the printing forme\", \"OK print\" and \"production printing\" on all kinds of commercially available production substrates. <em>ISO</em> <em>126</em>47-2:2013: is directly applicable to press proof prints and printing processes that use colour separation printing formes as input; is applicable to press proof prints and printing processes with more than four process colours as long as direct analogies to four-colour printing are maintained, such as for data and screening, for print substrates and printing parameters; is applicable to printing on cardboard material for packaging; is applicable for all kinds of drying methods such as heat-set, infrared, and ultraviolet; provides references for quality assurance and quality management. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/34/53425","uuid":"af09d124-f6b8-4bcc-ad37-2a2835114fe9","title":"ISO 12625-8:2010 Tissue paper and tissue products — Part 8: Water-absorption time and water-absorption capacity, basket-immersion test method","status":"Published","year":2021,"order":11,"text":"ISO 12625-8:2010 specifies a basket-immersion test method for the determination of water-absorption time and water-absorption capacity of tissue paper and tissue products. It is expressly stated that the detection of impurities and contraries in tissue paper and tissue products be applied according to ISO 15755. For the determination of moisture content in tissue paper and tissue products, ISO 287 is applicable. ","objectID":"53425_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-8:2010 Tissue paper and tissue products — Part 8: Water-absorption time and water-absorption capacity, basket-immersion test method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-8:2010 specifies a basket-immersion test method for the determination of water-absorption time and water-absorption capacity of tissue paper and tissue products. It is expressly stated that the detection of impurities and contraries in tissue paper and tissue products be applied according to <em>ISO</em> 15755. For the determination of moisture content in tissue paper and tissue products, <em>ISO</em> 287 is applicable. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51650","uuid":"9962d58b-4f88-4f1f-92f0-f9ebb15dbaaa","title":"ISO 12690:2010 Metallic and other inorganic coatings — Thermal spray coordination — Tasks and responsibilities","status":"Published","year":2021,"order":11,"text":"ISO 12690:2010 specifies the tasks and responsibilities necessary to ensure the quality of a thermal sprayed coating or a coated component, including the coordination of activities related to thermal spraying. Thermal spraying coordination can be carried out by one or a number of persons within the same company or manufacturing department. The responsibilities of the spraying coordinator are specified by the manufacturer. ","objectID":"51650_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>90:2010 Metallic and other inorganic coatings — Thermal spray coordination — Tasks and responsibilities","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>90:2010 specifies the tasks and responsibilities necessary to ensure the quality of a thermal sprayed coating or a coated component, including the coordination of activities related to thermal spraying. Thermal spraying coordination can be carried out by one or a number of persons within the same company or manufacturing department. The responsibilities of the spraying coordinator are specified by the manufacturer. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51551","uuid":"760a259b-a4be-47a7-8846-34cb24216441","title":"ISO 12609-2:2013 Eyewear for protection against intense light sources used on humans and animals for cosmetic and medical applications — Part 2: Guidance for use","status":"Published","year":2021,"order":11,"text":"ISO 12609-2:2013 gives guidance and information to users, manufacturers, suppliers, and safety advisors on the selection and use of eye protectors for intense light source (ILS) equipment used on humans and animals for cosmetic and medical applications against excessive exposure to optical radiation in the spectral range 250 nm to 3 000 nm, with the exception of laser radiation. ISO 12609-2:2013 provides guidance on selection of an eye protector expected to cope with the majority of applications and a more rigorous procedure for determining appropriate eye protection against spectral outputs from ILS equipment. ","objectID":"51551_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>09-2:2013 Eyewear for protection against intense light sources used on humans and animals for cosmetic and medical applications — Part 2: Guidance for use","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>09-2:2013 gives guidance and information to users, manufacturers, suppliers, and safety advisors on the selection and use of eye protectors for intense light source (ILS) equipment used on humans and animals for cosmetic and medical applications against excessive exposure to optical radiation in the spectral range 250 nm to 3 000 nm, with the exception of laser radiation. <em>ISO</em> <em>126</em>09-2:2013 provides guidance on selection of an eye protector expected to cope with the majority of applications and a more rigorous procedure for determining appropriate eye protection against spectral outputs from ILS equipment. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/56/45620","uuid":"46fd383c-1562-4a0f-8095-4379034c173b","title":"ISO 12625-12:2010 Tissue paper and tissue products — Part 12: Determination of tensile strength of perforated lines — Calculation of perforation efficiency","status":"Published","year":2021,"order":11,"text":"ISO 12625-12:2010 specifies a test method for the determination of the tensile strength of perforated lines of tissue paper. It uses a tensile-testing apparatus operating with a constant rate of elongation. This method is only used for measuring machine-direction tensile strength, that is for cross-direction perforations on tissue paper. The calculation of perforation efficiency is also specified in ISO 12625-12:2010. ","objectID":"45620_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-12:2010 Tissue paper and tissue products — Part 12: Determination of tensile strength of perforated lines — Calculation of perforation efficiency","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-12:2010 specifies a test method for the determination of the tensile strength of perforated lines of tissue paper. It uses a tensile-testing apparatus operating with a constant rate of elongation. This method is only used for measuring machine-direction tensile strength, that is for cross-direction perforations on tissue paper. The calculation of perforation efficiency is also specified in <em>ISO</em> <em>126</em>25-12:2010. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/51/45115","uuid":"19d8dedf-a104-445e-ad87-474934ee1f82","title":"ISO 12640-4:2011 Graphic technology — Prepress digital data exchange — Part 4: Wide gamut display-referred standard colour image data [Adobe RGB (1998)/SCID]","status":"Published","year":2021,"order":11,"text":"ISO 12640-4:2011 specifies a set of standard wide gamut display-referred colour images [encoded as 16-bit Adobe RGB (1998) digital data] that can be used for the evaluation of changes in image quality during coding, image processing (including colour re-rendering and colour space transformations, compression and decompression), displaying on a colour monitor and printing. These images can be used for research, testing and assessing of output systems such as printers, colour management systems and colour profiles. ","objectID":"45115_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>40-4:2011 Graphic technology — Prepress digital data exchange — Part 4: Wide gamut display-referred standard colour image data [Adobe RGB (1998)/SCID]","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>40-4:2011 specifies a set of standard wide gamut display-referred colour images [encoded as 16-bit Adobe RGB (1998) digital data] that can be used for the evaluation of changes in image quality during coding, image processing (including colour re-rendering and colour space transformations, compression and decompression), displaying on a colour monitor and printing. These images can be used for research, testing and assessing of output systems such as printers, colour management systems and colour profiles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/51/35110","uuid":"a3914794-3fff-4b60-8efb-ab723780f2c0","title":"ISO 12640-3:2007 Graphic technology — Prepress digital data exchange — Part 3: CIELAB standard colour image data (CIELAB/SCID)","status":"Published","year":2021,"order":11,"text":"ISO 12640-3:2007 specifies a set of standard large gamut colour images (encoded as 16-bit CIELAB digital data) that can be used for the evaluation of changes in image quality during coding, image processing (including transformation, compression and decompression), displaying on a colour monitor and printing. These images can be used for research, testing and assessing of output systems such as printers, colour management systems and colour profiles. ","objectID":"35110_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>40-3:2007 Graphic technology — Prepress digital data exchange — Part 3: CIELAB standard colour image data (CIELAB/SCID)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>40-3:2007 specifies a set of standard large gamut colour images (encoded as 16-bit CIELAB digital data) that can be used for the evaluation of changes in image quality during coding, image processing (including transformation, compression and decompression), displaying on a colour monitor and printing. These images can be used for research, testing and assessing of output systems such as printers, colour management systems and colour profiles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/38/33870","uuid":"81f4c9c9-6c3e-4535-af8d-5ce2ee9ecd50","title":"ISO 12676:2000 Refractory products — Determination of resistance to carbon monoxide","status":"Published","year":2021,"order":11,"text":"This International Standard specifies a method for determining the comparative resistance of refractory materials to carbon monoxide disintegration. The test is intended to be more severe than conditions encountered in service in order to enable probable behaviour of refractory materials to be assessed in a relatively short time. ","objectID":"33870_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>76:2000 Refractory products — Determination of resistance to carbon monoxide","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This International Standard specifies a method for determining the comparative resistance of refractory materials to carbon monoxide disintegration. The test is intended to be more severe than conditions encountered in service in order to enable probable behaviour of refractory materials to be assessed in a relatively short time. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/22/32214","uuid":"6719c2cc-f843-4e8b-8872-2cf285632442","title":"ISO 12683:2004 Mechanically deposited coatings of zinc — Specification and test methods","status":"Published","year":2021,"order":11,"text":"ISO 12683:2004 specifies the requirements for coatings of zinc that have been mechanically deposited on to fabricated metal articles to protect them from corrosion. It also describes the related test methods. ","objectID":"32214_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>83:2004 Mechanically deposited coatings of zinc — Specification and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>83:2004 specifies the requirements for coatings of zinc that have been mechanically deposited on to fabricated metal articles to protect them from corrosion. It also describes the related test methods. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/21/32183","uuid":"f84e2ce8-26fe-4440-81e9-650620cf18a8","title":"ISO 12632:2015 Graphic technology — Ink, paper and labels — Requirements on hot alkali penetration and resistance","status":"Published","year":2021,"order":11,"text":"ISO 12632:2015 specifies test methods for -      penetrability and removal times of labels that have been wet glued on bottles intended to be refilled and reused, and -      resistance of printed labels against hot alkaline solution. Test results always deal with systems comprising of substrates, ink films and varnish films if present. This International Standard is valid for label substrates and printed labels. Label substrates include metalized papers. The test procedures are also valid for the evaluation of inks and papers to be used in printing labels. ISO 12632:2015 does not purport to address all of the safety concerns, if any, associated with its use. It is the responsibility of the user of this International Standard to establish appropriate safety and health practices and determine the applicability of regulatory limitations prior to use. ","objectID":"32183_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>32:2015 Graphic technology — Ink, paper and labels — Requirements on hot alkali penetration and resistance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>32:2015 specifies test methods for -      penetrability and removal times of labels that have been wet glued on bottles intended to be refilled and reused, and -      resistance of printed labels against hot alkaline solution. Test results always deal with systems comprising of substrates, ink films and varnish films if present. This International Standard is valid for label substrates and printed labels. Label substrates include metalized papers. The test procedures are also valid for the evaluation of inks and papers to be used in printing labels. <em>ISO</em> <em>126</em>32:2015 does not purport to address all of the safety concerns, if any, associated with its use. It is the responsibility of the user of this International Standard to establish appropriate safety and health practices and determine the applicability of regulatory limitations prior to use. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/72/27249","uuid":"bd90e390-ba80-49bb-b040-6371cfe91c2a","title":"ISO 1268-7:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 7: Resin transfer moulding","status":"Published","year":2021,"order":11,"objectID":"27249_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>8-7:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 7: Resin transfer moulding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/72/27247","uuid":"68551d93-a1a1-4e81-ada6-d9e248476f59","title":"ISO 1268-5:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 5: Filament winding","status":"Published","year":2021,"order":11,"objectID":"27247_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>8-5:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 5: Filament winding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/72/27244","uuid":"b991805c-2926-4812-b366-fbd1392b1a59","title":"ISO 1268-2:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 2: Contact and spray-up moulding","status":"Published","year":2021,"order":11,"objectID":"27244_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>8-2:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 2: Contact and spray-up moulding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25213","uuid":"ab51feab-b757-4f12-ae36-42b92fb91680","title":"ISO 1268-1:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 1: General conditions","status":"Published","year":2021,"order":11,"text":"The various parts of ISO 1268 (see the foreword) describe methods used to prepare reinforced-plastics plates from which test specimens can be cut. This allows the properties of a composite, or the constituents of the composite, to be determined. The methods are intended to cover all the main types of reinforcement and resin matrix. The choice of test plate preparation method depends on: a) the reinforcement:  its nature (glass, carbon, aramid, etc.);  its form (roving, mat, woven fabric, etc.);  its orientation with respect to the length, width and thickness of the plate;  its content in the reinforced plastic; b) the matrix (thermosetting or thermoplastic); c) the magnitude expected for the properties; d) the production process that is to be evaluated. Since the mechanical properties of a reinforced plastic are known to be dependent on the process by which the plastic is produced, it is recommended that the test plates be prepared, if possible, by the same method that will be used to produce the plastic. This part of ISO 1268 describes the general requirements common to all the methods. ","objectID":"25213_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>8-1:2001 Fibre-reinforced plastics — Methods of producing test plates — Part 1: General conditions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"The various parts of <em>ISO</em> <em>126</em>8 (see the foreword) describe methods used to prepare reinforced-plastics plates from which test specimens can be cut. This allows the properties of a composite, or the constituents of the composite, to be determined. The methods are intended to cover all the main types of reinforcement and resin matrix. The choice of test plate preparation method depends on: a) the reinforcement:  its nature (glass, carbon, aramid, etc.);  its form (roving, mat, woven fabric, etc.);  its orientation with respect to the length, width and thickness of the plate;  its content in the reinforced plastic; b) the matrix (thermosetting or thermoplastic); c) the magnitude expected for the properties; d) the production process that is to be evaluated. Since the mechanical properties of a reinforced plastic are known to be dependent on the process by which the plastic is produced, it is recommended that the test plates be prepared, if possible, by the same method that will be used to produce the plastic. This part of <em>ISO</em> <em>126</em>8 describes the general requirements common to all the methods. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/96/19694","uuid":"36f9b9d1-0d55-4978-8118-939e95e003ef","title":"ISO 12667:1993 Commercial vehicles and buses — Cross-tooth propeller shaft flanges, type T","status":"Published","year":2021,"order":11,"text":"Specifies the nominal dimensions and tolerances which affect interchangeability as well as designation. Dimensions and tolerances of the mating parts, i.e. type T cross-tooth gearbox flanges, are specified in ISO 8667. ","objectID":"19694_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>67:1993 Commercial vehicles and buses — Cross-tooth propeller shaft flanges, type T","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"Specifies the nominal dimensions and tolerances which affect interchangeability as well as designation. Dimensions and tolerances of the mating parts, i.e. type T cross-tooth gearbox flanges, are specified in <em>ISO</em> 8667. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/18/1854","uuid":"3a2d6c1d-6ae9-4536-92bc-8161be347d96","title":"ISO 12645:1998 Graphic technology — Process control — Certified reference material for opaque area calibration of transmission densitometers","status":"Published","year":2021,"order":11,"text":"This International Standard defines requirements for a half-tone certified reference material which may be used for the opaque area percentage calibration of transmission densitometers or colorimeters for use in the graphic arts. This International Standard is not applicable to the calibration of transmission densitometers in terms of ISO standard diffuse density. NOTE Test methods for determining the opaque area percentage are given in the informative annex A. ","objectID":"1854_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>45:1998 Graphic technology — Process control — Certified reference material for opaque area calibration of transmission densitometers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This International Standard defines requirements for a half-tone certified reference material which may be used for the opaque area percentage calibration of transmission densitometers or colorimeters for use in the graphic arts. This International Standard is not applicable to the calibration of transmission densitometers in terms of <em>ISO</em> standard diffuse density. NOTE Test methods for determining the opaque area percentage are given in the informative annex A. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1643","uuid":"7a36ebe9-dfa1-4db9-8af8-52822f4c01ce","title":"ISO 12687:1996 Metallic coatings — Porosity tests — Humid sulfur (flowers of sulfur) test","status":"Published","year":2021,"order":11,"text":"Specifies a method of revealing discontinuities and porosity in metallic coatings, where they penetrate the coating layer down to a substrate. Especially useful for coatings consisting of single or combined layers. ","objectID":"1643_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>87:1996 Metallic coatings — Porosity tests — Humid sulfur (flowers of sulfur) test","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"Specifies a method of revealing discontinuities and porosity in metallic coatings, where they penetrate the coating layer down to a substrate. Especially useful for coatings consisting of single or combined layers. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/52/75219","uuid":"4a1f27dc-3dcd-4749-a3a0-db768e878727","title":"ISO 12647-6:2020 Graphic technology — Process control for the production of half-tone colour separations, proofs and production prints — Part 6: Flexographic printing","status":"Published","year":2020,"order":11,"text":"This document specifies the requirements for the exchange of data and information necessary for the definition of the aims for four-colour flexographic printing of packaging and publication materials, including newsprint. It is based on the use of colour characterization data to define the colourimetric printing aims and includes appropriate assignment of responsibility for and recommended tolerances on critical parameters of the flexographic printing process. This document is directly applicable to: —     publication flexographic printing including magazines, catalogues and commercial materials and packaging flexographic printing including labels, boxes, and flexible packages; —     half-tone and continuous tone proofing processes that predict the colourimetric results of flexographic printing. Guidance is also provided concerning the definition of spot colours used in flexographic printing. ","objectID":"75219_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-6:2020 Graphic technology — Process control for the production of half-tone colour separations, proofs and production prints — Part 6: Flexographic printing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies the requirements for the exchange of data and information necessary for the definition of the aims for four-colour flexographic printing of packaging and publication materials, including newsprint. It is based on the use of colour characterization data to define the colourimetric printing aims and includes appropriate assignment of responsibility for and recommended tolerances on critical parameters of the flexographic printing process. This document is directly applicable to: —     publication flexographic printing including magazines, catalogues and commercial materials and packaging flexographic printing including labels, boxes, and flexible packages; —     half-tone and continuous tone proofing processes that predict the colourimetric results of flexographic printing. Guidance is also provided concerning the definition of spot colours used in flexographic printing. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/11/71133","uuid":"4c7aba0c-a5e8-4722-9f88-48bdb4de180e","title":"ISO 12696:2016 Cathodic protection of steel in concrete","status":"Published","year":2020,"order":11,"text":"ISO 12696:2016 specifies performance requirements for cathodic protection of steel in cement-based concrete, in both new and existing structures. It covers building and civil engineering structures, including normal reinforcement and prestressed reinforcement embedded in the concrete. It is applicable to uncoated steel reinforcement and to organic-coated steel reinforcement. ISO 12696:2016 applies to steel embedded in atmospherically exposed, buried, immersed and tidal elements of buildings or structures. NOTE 1       Annex A gives guidance on the principles of cathodic protection and its application to steel in concrete. NOTE 2       ISO 12696:2016, while not specifically intended to address cathodic protection of steel in any electrolyte except concrete, can be applied to cathodic protection of steel in other cementitious materials such as are found, for example, in early 20th century steel-framed masonry, brick and terracotta clad buildings. In such applications, additional considerations specific to these structures are required in respect of design, materials and installation of cathodic protection; however, the requirements of this document can be applied to these systems. ","objectID":"71133_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>96:2016 Cathodic protection of steel in concrete","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>96:2016 specifies performance requirements for cathodic protection of steel in cement-based concrete, in both new and existing structures. It covers building and civil engineering structures, including normal reinforcement and prestressed reinforcement embedded in the concrete. It is applicable to uncoated steel reinforcement and to organic-coated steel reinforcement. <em>ISO</em> <em>126</em>96:2016 applies to steel embedded in atmospherically exposed, buried, immersed and tidal elements of buildings or structures. NOTE 1       Annex A gives guidance on the principles of cathodic protection and its application to steel in concrete. NOTE 2       <em>ISO</em> <em>126</em>96:2016, while not specifically intended to address cathodic protection of steel in any electrolyte except concrete, can be applied to cathodic protection of steel in other cementitious materials such as are found, for example, in early 20th century steel-framed masonry, brick and terracotta clad buildings. In such applications, additional considerations specific to these structures are required in respect of design, materials and installation of cathodic protection; however, the requirements of this document can be applied to these systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70692","uuid":"bf02a70a-9941-46eb-be2b-2e6198ba09d5","title":"ISO 12619-16:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 16: Fittings","status":"Published","year":2020,"order":11,"text":"ISO 12619-16:2017 specifies tests and requirements for the fittings, compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system components intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-16:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-16:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70692_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-16:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 16: Fittings","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-16:2017 specifies tests and requirements for the fittings, compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system components intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-16:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-16:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70691","uuid":"61bab5b5-c361-40fb-ae07-fde0fff7d530","title":"ISO 12619-15:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 15: Filter","status":"Published","year":2020,"order":11,"text":"ISO 12619-15:2017 specifies tests and requirements for the filter, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-15:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-15:2017  are considered gauge pressures unless otherwise specified. ","objectID":"70691_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-15:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 15: Filter","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-15:2017 specifies tests and requirements for the filter, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-15:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-15:2017  are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70690","uuid":"7638794b-2e1b-4d20-9255-f7b63b332ea2","title":"ISO 12619-14:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 14: Flexible fuel line","status":"Published","year":2020,"order":11,"text":"ISO 12619-14:2017 specifies tests and requirements for the flexible fuel line, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-14:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-14:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70690_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-14:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 14: Flexible fuel line","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-14:2017 specifies tests and requirements for the flexible fuel line, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-14:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-14:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70689","uuid":"95eae62a-9aa6-4ce2-b5ab-fd74d05a1670","title":"ISO 12619-13:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 13: Rigid fuel line in stainless steel","status":"Published","year":2020,"order":11,"text":"ISO 12619-13:2017 specifies tests and requirements for the rigid fuel line in stainless steel, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-13:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-13:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70689_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-13:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 13: Rigid fuel line in stainless steel","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-13:2017 specifies tests and requirements for the rigid fuel line in stainless steel, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-13:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-13:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70688","uuid":"404343bd-6cf7-4048-8d75-3d461db71881","title":"ISO 12619-12:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 12: Gas-tight housing and ventilation hoses","status":"Published","year":2020,"order":11,"text":"ISO 12619-12:2017 specifies tests and requirements for the gas-tight housing and ventilation hose, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-12:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-12:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70688_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-12:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 12: Gas-tight housing and ventilation hoses","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-12:2017 specifies tests and requirements for the gas-tight housing and ventilation hose, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-12:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-12:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70687","uuid":"8526976e-4abf-4213-91d2-a585444b4033","title":"ISO 12619-11:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 11: Excess flow valve","status":"Published","year":2020,"order":11,"text":"ISO 12619-11:2017specifies tests and requirements for the excess flow valve, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-11:2017and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-11:2017are considered gauge pressures unless otherwise specified. ","objectID":"70687_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-11:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 11: Excess flow valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-11:2017specifies tests and requirements for the excess flow valve, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-11:2017and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-11:2017are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70686","uuid":"d8118866-49f6-4dc7-812f-c9ea6e8c7f2f","title":"ISO 12619-10:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 10: Pressure relief device (PRD)","status":"Published","year":2020,"order":11,"text":"ISO 12619-10:2017 specifies tests and requirements for the pressure relief device (PRD), a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2    All references to pressure in this document are considered gauge pressures unless otherwise specified. ","objectID":"70686_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-10:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 10: Pressure relief device (PRD)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-10:2017 specifies tests and requirements for the pressure relief device (PRD), a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2    All references to pressure in this document are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70685","uuid":"40fba2f7-8cf6-4b00-8e05-2560c952e2e7","title":"ISO 12619-9:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 9: Pressure relief valve (PRV)","status":"Published","year":2020,"order":11,"text":"ISO 12619-9:2017 specifies tests and requirements for the pressure relief valve (PRV), a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)     liquefied hydrogen (LH 2 ) fuel system components; b)     fuel containers; c)     stationary gas engines; d)     container mounting hardware; e)     electronic fuel management; f)      refuelling receptacles; g)     fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-9:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-9:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70685_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-9:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 9: Pressure relief valve (PRV)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-9:2017 specifies tests and requirements for the pressure relief valve (PRV), a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)     liquefied hydrogen (LH 2 ) fuel system components; b)     fuel containers; c)     stationary gas engines; d)     container mounting hardware; e)     electronic fuel management; f)      refuelling receptacles; g)     fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-9:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-9:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70684","uuid":"d8ac9da1-e02a-4fc4-b76b-4f301afb8cad","title":"ISO 12619-8:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 8: Pressure indicator","status":"Published","year":2020,"order":11,"text":"ISO 12619-8:2017 specifies tests and requirements for the pressure indicator, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using CGH 2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blend using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of ISO 12619-8:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in ISO 12619-8:2017 are considered gauge pressures unless otherwise specified. ","objectID":"70684_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-8:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 8: Pressure indicator","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-8:2017 specifies tests and requirements for the pressure indicator, a compressed gaseous hydrogen (CGH 2 ) and hydrogen/natural gas blend fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using CGH 2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blend using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH 2 ) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of <em>ISO</em> <em>126</em>19-8:2017 and tested according to the appropriate functional tests. NOTE 2    All references to pressure in <em>ISO</em> <em>126</em>19-8:2017 are considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70683","uuid":"6bbf7421-23e6-4d3a-9b9a-b0f49c29437b","title":"ISO 12619-7:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 7: Gas injector","status":"Published","year":2020,"order":11,"text":"ISO 12619-7:2017 specifies tests and requirements for the gas injector and/or fuel rail, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in ISO 3833. ISO 12619-7:2017 is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with ISO 14687‑1 or ISO 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403‑1 and ISO/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2    All references to pressure in this document are to be considered gauge pressures unless otherwise specified. ","objectID":"70683_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-7:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 7: Gas injector","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-7:2017 specifies tests and requirements for the gas injector and/or fuel rail, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. <em>ISO</em> <em>126</em>19-7:2017 is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with <em>ISO</em> 14687‑1 or <em>ISO</em> 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403‑1 and <em>ISO</em>/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles; g)    fuel cell vehicles. NOTE 1    It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2    All references to pressure in this document are to be considered gauge pressures unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/95/69550","uuid":"c8498cb7-ce5c-4769-8f58-7ed8c9aa0489","title":"ISO 12620:2019 Management of terminology resources — Data category specifications","status":"Published","year":2020,"order":11,"text":"This document provides guidelines and requirements governing data category specifications for language resources. It specifies mechanisms for creating, documenting, harmonizing and maintaining data category specifications in a data category repository. It also describes the structure and content of data category specifications. The intended audience of this document is researchers and practitioners in fields of language resource management who use data categories and data category specifications. ","objectID":"69550_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>20:2019 Management of terminology resources — Data category specifications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document provides guidelines and requirements governing data category specifications for language resources. It specifies mechanisms for creating, documenting, harmonizing and maintaining data category specifications in a data category repository. It also describes the structure and content of data category specifications. The intended audience of this document is researchers and practitioners in fields of language resource management who use data categories and data category specifications. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/81/68147","uuid":"8fe9646b-4494-41bb-8aae-41da76f94368","title":"ISO 12619-5:2016 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 5: Manual cylinder valve","status":"Published","year":2020,"order":11,"text":"ISO 12619-5:2016 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in ISO 3833. It also provides general design principles and specifies requirements for instructions and markings. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components located upstream of, and including, the vaporizer; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. ","objectID":"68147_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-5:2016 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 5: Manual cylinder valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-5:2016 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It also provides general design principles and specifies requirements for instructions and markings. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components located upstream of, and including, the vaporizer; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/81/68146","uuid":"ee7dfc51-c30c-4457-b999-9b63c20ee251","title":"ISO 12619-4:2016 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 4: Check valve","status":"Published","year":2020,"order":11,"text":"ISO 12619-4:2016 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in ISO 3833. It also provides general design principles and specifies requirements for instructions and markings. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with ISO 14687‑1 or ISO 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403‑1 and ISO/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components located upstream of, and including, the vaporizer; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. ","objectID":"68146_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-4:2016 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 4: Check valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-4:2016 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It also provides general design principles and specifies requirements for instructions and markings. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with <em>ISO</em> 14687‑1 or <em>ISO</em> 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403‑1 and <em>ISO</em>/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components located upstream of, and including, the vaporizer; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/81/68132","uuid":"185a2fab-8e6a-4b2b-86d8-212bc5dbc7ca","title":"ISO 12619-6:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 6: Automatic valve","status":"Published","year":2020,"order":11,"text":"ISO 12619-6:2017 specifies tests and requirements for the automatic valve, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in ISO 3833. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with ISO 14687‑1 or ISO 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403‑1 and ISO/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. NOTE 1       It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2       All references to pressure in this document are to be considered gauge pressures unless otherwise specified. NOTE 3       This document may not apply to fuel cell vehicles in compliance with international regulations. ","objectID":"68132_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-6:2017 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 6: Automatic valve","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-6:2017 specifies tests and requirements for the automatic valve, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It is applicable to vehicles using compressed gaseous hydrogen (CGH2) in accordance with <em>ISO</em> 14687‑1 or <em>ISO</em> 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403‑1 and <em>ISO</em>/TR 15403‑2. It is not applicable to the following: a)    liquefied hydrogen (LH2) fuel system components; b)    fuel containers; c)    stationary gas engines; d)    container mounting hardware; e)    electronic fuel management; f)     refuelling receptacles. NOTE 1       It is recognized that miscellaneous components not specifically covered herein can be examined to meet the criteria of this document and tested according to the appropriate functional tests. NOTE 2       All references to pressure in this document are to be considered gauge pressures unless otherwise specified. NOTE 3       This document may not apply to fuel cell vehicles in compliance with international regulations. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/36/63610","uuid":"6b6ce909-9950-423a-a72d-963b39757993","title":"ISO 12625-9:2015 Tissue paper and tissue products — Part 9: Determination of ball burst strength","status":"Published","year":2020,"order":11,"text":"ISO 12625-9:2015 specifies a test method for the determination of the resistance to mechanical penetration (ball burst strength procedure) of tissue paper and tissue products. Currently, two types of clamping devices are available on the market with two different diameters, one is with 50 mm and one is with 89 mm. ISO 12625-9:2015 applies for a 50 mm clamping device to be able to measure all sample sizes of tissue paper and tissue products and to be consistent with ISO 12625-11. ","objectID":"63610_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-9:2015 Tissue paper and tissue products — Part 9: Determination of ball burst strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-9:2015 specifies a test method for the determination of the resistance to mechanical penetration (ball burst strength procedure) of tissue paper and tissue products. Currently, two types of clamping devices are available on the market with two different diameters, one is with 50 mm and one is with 89 mm. <em>ISO</em> <em>126</em>25-9:2015 applies for a 50 mm clamping device to be able to measure all sample sizes of tissue paper and tissue products and to be consistent with <em>ISO</em> <em>126</em>25-11. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/04/60479","uuid":"f1fcf058-b240-4c35-bbbc-491e887e0eb1","title":"ISO 12647-5:2015 Graphic technology — Process control for the manufacture of half-tone colour separations, proof and production prints — Part 5: Screen printing","status":"Published","year":2020,"order":11,"text":"ISO 12647-5:2014 specifies the requirements for the screen printing of four-colour process-colour material used for display, signage, and graphics using flat bed or cylinder printing equipment. Both the size and resolution of the finished product are unrestricted. The process stages included are data preparation and delivery, proof production, printing forme preparation, and production printing. ","objectID":"60479_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-5:2015 Graphic technology — Process control for the manufacture of half-tone colour separations, proof and production prints — Part 5: Screen printing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>47-5:2014 specifies the requirements for the screen printing of four-colour process-colour material used for display, signage, and graphics using flat bed or cylinder printing equipment. Both the size and resolution of the finished product are unrestricted. The process stages included are data preparation and delivery, proof production, printing forme preparation, and production printing. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5866","uuid":"f837987b-328f-4a36-a674-551accadc749","title":"ISO 1264:1980 Plastics — Homopolymer and copolymer resins of vinyl chloride — Determination of pH of aqueous extract","status":"Published","year":2020,"order":11,"text":"Treatment of a test portion of resin with a given volume of an aqueous solution of sodium chloride previous neutralized to pH 7,0. After stirring and decanting, measurement of the potential difference existing between a glass electrode and a reference calomel electrode immersed in the liquid maintained at 23 °C and reading of this difference, expressed in pH units directly on th pH meter scale. ","objectID":"5866_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>4:1980 Plastics — Homopolymer and copolymer resins of vinyl chloride — Determination of pH of aqueous extract","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"Treatment of a test portion of resin with a given volume of an aqueous solution of sodium chloride previous neutralized to pH 7,0. After stirring and decanting, measurement of the potential difference existing between a glass electrode and a reference calomel electrode immersed in the liquid maintained at 23 °C and reading of this difference, expressed in pH units directly on th pH meter scale. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/73/57311","uuid":"02ad6808-a1b3-485e-a5b2-ccd918587d45","title":"ISO 12646:2015 Graphic technology — Displays for colour proofing — Characteristics","status":"Published","year":2020,"order":11,"text":"ISO 12646:2015 specifies requirements for two conformance levels for the characteristics of displays to be used for soft proofing of colour images. Included are requirements for uniformity and variations of electro-optical properties with viewing direction for different driving signals. ","objectID":"57311_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>46:2015 Graphic technology — Displays for colour proofing — Characteristics","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>46:2015 specifies requirements for two conformance levels for the characteristics of displays to be used for soft proofing of colour images. Included are requirements for uniformity and variations of electro-optical properties with viewing direction for different driving signals. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51604","uuid":"c3d51dce-8994-4289-bf3e-a9ca80165b4d","title":"ISO 12629:2011 Thermal insulating products for building equipment and industrial installations — Determination of water vapour transmission properties of preformed pipe insulation","status":"Published","year":2020,"order":11,"text":"ISO 12629:2011 specifies the equipment and procedure for determining the water vapour transmission properties in the steady state under specified test conditions for test specimens of preformed pipe insulation. It is applicable to thermal insulating products. ","objectID":"51604_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>29:2011 Thermal insulating products for building equipment and industrial installations — Determination of water vapour transmission properties of preformed pipe insulation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>29:2011 specifies the equipment and procedure for determining the water vapour transmission properties in the steady state under specified test conditions for test specimens of preformed pipe insulation. It is applicable to thermal insulating products. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51603","uuid":"de103034-d6b2-4125-bccd-b4c659f915fc","title":"ISO 12628:2011 Thermal insulating products for building equipment and industrial installations — Determination of dimensions, squareness and linearity of preformed pipe insulation","status":"Published","year":2020,"order":11,"text":"ISO 12628:2011 specifies the equipment and procedures for determining the dimensions, squareness and linearity of preformed pipe insulation, supplied in one piece, half sections or segments. It is applicable to thermal insulating products. ","objectID":"51603_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>28:2011 Thermal insulating products for building equipment and industrial installations — Determination of dimensions, squareness and linearity of preformed pipe insulation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>28:2011 specifies the equipment and procedures for determining the dimensions, squareness and linearity of preformed pipe insulation, supplied in one piece, half sections or segments. It is applicable to thermal insulating products. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51602","uuid":"58874d6d-c06d-4110-b675-f91f3cf84d10","title":"ISO 12624:2011 Thermal insulating products for building equipment and industrial installations — Determination of trace quantities of water soluble chloride, fluoride, silicate, sodium ions and pH","status":"Published","year":2020,"order":11,"text":"ISO 12624:2011 specifies the equipment and procedures for determining trace quantities of the water soluble chloride, fluoride, silicate and sodium ions in an aqueous extract of the product. It also describes a procedure for the determination of the pH of the aqueous extract. ISO 12624:2011 is applicable to thermal insulating products. ","objectID":"51602_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>24:2011 Thermal insulating products for building equipment and industrial installations — Determination of trace quantities of water soluble chloride, fluoride, silicate, sodium ions and pH","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>24:2011 specifies the equipment and procedures for determining trace quantities of the water soluble chloride, fluoride, silicate and sodium ions in an aqueous extract of the product. It also describes a procedure for the determination of the pH of the aqueous extract. <em>ISO</em> <em>126</em>24:2011 is applicable to thermal insulating products. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51601","uuid":"9ae65059-bd2f-4411-ba1e-42438e3fed07","title":"ISO 12623:2011 Thermal insulating products for building equipment and industrial installations — Determination of short-term water absorption by partial immersion of preformed pipe insulation","status":"Published","year":2020,"order":11,"text":"ISO 12623:2011 specifies the equipment and procedures for determining the short-term water absorption of preformed pipe insulation by partial immersion in water. It is applicable to thermal insulating products. ","objectID":"51601_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>23:2011 Thermal insulating products for building equipment and industrial installations — Determination of short-term water absorption by partial immersion of preformed pipe insulation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>23:2011 specifies the equipment and procedures for determining the short-term water absorption of preformed pipe insulation by partial immersion in water. It is applicable to thermal insulating products. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51571","uuid":"068193cf-d1e9-4293-aaf3-bf24a461ab73","title":"ISO 12619-3:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 3: Pressure regulator","status":"Published","year":2020,"order":11,"text":"ISO 12619-3:2014 specifies tests and requirements for the pressure regulator, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in ISO 3833. ISO 12619-3:2014 is applicable to vehicles using CGH2 in accordance with ISO 14687‑1 or ISO 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403‑1 and ISO/TR 15403‑2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","objectID":"51571_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-3:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 3: Pressure regulator","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-3:2014 specifies tests and requirements for the pressure regulator, a compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system component intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. <em>ISO</em> <em>126</em>19-3:2014 is applicable to vehicles using CGH2 in accordance with <em>ISO</em> 14687‑1 or <em>ISO</em> 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403‑1 and <em>ISO</em>/TR 15403‑2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51570","uuid":"f1876bba-eef3-4f1c-96e4-54d87fb30004","title":"ISO 12619-2:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 2: Performance and general test methods","status":"Published","year":2020,"order":11,"text":"ISO 12619-2:2014 specifies performance and general test methods for compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in ISO 3833. This part of ISO 12619-2:2014 is applicable to vehicles using CGH2 in accordance with ISO 14687‑1 or ISO 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403‑1 and ISO/TR 15403‑2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","objectID":"51570_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-2:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 2: Performance and general test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-2:2014 specifies performance and general test methods for compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. This part of <em>ISO</em> <em>126</em>19-2:2014 is applicable to vehicles using CGH2 in accordance with <em>ISO</em> 14687‑1 or <em>ISO</em> 14687‑2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403‑1 and <em>ISO</em>/TR 15403‑2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51569","uuid":"74b96fbb-de60-4941-9e12-501a8b1c3ff4","title":"ISO 12619-1:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 1: General requirements and definitions","status":"Published","year":2020,"order":11,"text":"ISO 12619-1:2014 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in ISO 3833. It also provides general design principles and specifies requirements for instructions and markings. ISO 12619-1:2014 is applicable to vehicles using CGH2 in accordance with ISO 14687-1 or ISO 14687-2 and hydrogen/natural gas blends using natural gas in accordance with ISO 15403-1 and ISO/TR 15403-2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","objectID":"51569_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>19-1:2014 Road vehicles — Compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components — Part 1: General requirements and definitions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>19-1:2014 specifies general requirements and definitions of compressed gaseous hydrogen (CGH2) and hydrogen/natural gas blends fuel system components, intended for use on the types of motor vehicles defined in <em>ISO</em> 3833. It also provides general design principles and specifies requirements for instructions and markings. <em>ISO</em> <em>126</em>19-1:2014 is applicable to vehicles using CGH2 in accordance with <em>ISO</em> 14687-1 or <em>ISO</em> 14687-2 and hydrogen/natural gas blends using natural gas in accordance with <em>ISO</em> 15403-1 and <em>ISO</em>/TR 15403-2. It is not applicable to the following: -liquefied hydrogen (LH2) fuel system components; -fuel containers; -stationary gas engines; -container mounting hardware; -electronic fuel management; -refuelling receptacles. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51568","uuid":"32b0d368-4176-4f57-b85b-088c52f8f1a0","title":"ISO 12617:2015 Road vehicles — Liquefied natural gas (LNG) refuelling connector — 3,1 MPa connector","status":"Published","year":2020,"order":11,"text":"ISO 12617:2015 specifies liquefied natural gas (LNG) refuelling nozzles and receptacles constructed entirely of new and unused parts and materials for road vehicles powered by LNG. An LNG refuelling connector consists of, as applicable, the receptacle and its protective cap (mounted on the vehicle) and the nozzle. This International standard is applicable only to such devices designed for a maximum working pressure of 3,4 MPa (34 bar) to those using LNG as vehicle fuel and having standardized mating components. NOTE          All references to pressures given in megapascals and bar (1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 ) are to be considered gauge pressures, unless otherwise specified. ","objectID":"51568_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>17:2015 Road vehicles — Liquefied natural gas (LNG) refuelling connector — 3,1 MPa connector","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>17:2015 specifies liquefied natural gas (LNG) refuelling nozzles and receptacles constructed entirely of new and unused parts and materials for road vehicles powered by LNG. An LNG refuelling connector consists of, as applicable, the receptacle and its protective cap (mounted on the vehicle) and the nozzle. This International standard is applicable only to such devices designed for a maximum working pressure of 3,4 MPa (34 bar) to those using LNG as vehicle fuel and having standardized mating components. NOTE          All references to pressures given in megapascals and bar (1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm 2 ) are to be considered gauge pressures, unless otherwise specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/26/42673","uuid":"a43e2576-5292-451e-bf51-c3e345cfcb3b","title":"ISO 12651-2:2014 Electronic document management — Vocabulary — Part 2: Workflow management","status":"Published","year":2020,"order":11,"text":"ISO 12651-2:2014 defines terms and concepts relevant to electronic document workflow management. It is intended to facilitate communication in the field of electronic document management and translation of the terms and concepts it contains into other languages. It identifies the terminology used to describe the concepts and general structure of a workflow management system for electronic images and other electronic documents, its major functional components, and their interfaces. It also provides a list of synonyms variously used within the industry as alternative terms to the preferred terminology ","objectID":"42673_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>51-2:2014 Electronic document management — Vocabulary — Part 2: Workflow management","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>51-2:2014 defines terms and concepts relevant to electronic document workflow management. It is intended to facilitate communication in the field of electronic document management and translation of the terms and concepts it contains into other languages. It identifies the terminology used to describe the concepts and general structure of a workflow management system for electronic images and other electronic documents, its major functional components, and their interfaces. It also provides a list of synonyms variously used within the industry as alternative terms to the preferred terminology ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39371","uuid":"18dd9348-8246-43e1-a3d1-f2bfad490fa8","title":"ISO 12642-2:2006 Graphic technology — Input data for characterization of 4-colour process printing — Part 2: Expanded data set","status":"Published","year":2020,"order":11,"text":"ISO 12642-2:2006 defines a data set of ink value combinations that is intended to be used to characterize four-colour process printing. This data set is not optimized for any printing process or application area but is robust enough for all general applications. The needs of publication, commercial, and package printing with offset, gravure, flexography, and other printing processes have been considered. While it is primarily aimed at process colour printing with CMYK inks, it can also be used with any combination of three chromatic coloured inks and a dark ink. It is an alternate to the ISO 12642-1 data set where more robust data is required. ","objectID":"39371_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>42-2:2006 Graphic technology — Input data for characterization of 4-colour process printing — Part 2: Expanded data set","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>42-2:2006 defines a data set of ink value combinations that is intended to be used to characterize four-colour process printing. This data set is not optimized for any printing process or application area but is robust enough for all general applications. The needs of publication, commercial, and package printing with offset, gravure, flexography, and other printing processes have been considered. While it is primarily aimed at process colour printing with CMYK inks, it can also be used with any combination of three chromatic coloured inks and a dark ink. It is an alternate to the <em>ISO</em> <em>126</em>42-1 data set where more robust data is required. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/48/34842","uuid":"f583b731-bff0-49cc-af07-72c5c961f6e3","title":"ISO 1265:2007 Plastics — Poly(vinyl chloride) resins — Determination of number of impurities and foreign particles","status":"Published","year":2020,"order":11,"text":"ISO 1265:2007 specifies a method for determining the number of impurities and foreign particles in a flattened surface of poly(vinyl chloride) resin. It is not applicable to paste resins because of their finely divided state. ","objectID":"34842_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>5:2007 Plastics — Poly(vinyl chloride) resins — Determination of number of impurities and foreign particles","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>5:2007 specifies a method for determining the number of impurities and foreign particles in a flattened surface of poly(vinyl chloride) resin. It is not applicable to paste resins because of their finely divided state. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/72/27245","uuid":"1c9f7e49-1b86-4474-9da4-44e9ba50bbe0","title":"ISO 1268-3:2000 Fibre-reinforced plastics — Methods of producing test plates — Part 3: Wet compression moulding","status":"Published","year":2020,"order":11,"objectID":"27245_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>8-3:2000 Fibre-reinforced plastics — Methods of producing test plates — Part 3: Wet compression moulding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/21/2105","uuid":"93bfe049-2c3a-4d40-af42-9185609b04bd","title":"ISO 12640-1:1997 Graphic technology — Prepress digital data exchange — Part 1: CMYK standard colour image data (CMYK/SCID)","status":"Published","year":2020,"order":11,"objectID":"2105_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>40-1:1997 Graphic technology — Prepress digital data exchange — Part 1: CMYK standard colour image data (CMYK/SCID)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/63/76349","uuid":"4f75e3c0-a7c8-4c4e-9599-cb2429a3cc7c","title":"ISO 12625-11:2019 Tissue paper and tissue products — Part 11: Determination of wet ball burst strength","status":"Published","year":2019,"order":11,"text":"This document specifies a test method for the determination of the resistance to mechanical penetration (ball burst strength procedure) of tissue paper and tissue products after wetting. ","objectID":"76349_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-11:2019 Tissue paper and tissue products — Part 11: Determination of wet ball burst strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document specifies a test method for the determination of the resistance to mechanical penetration (ball burst strength procedure) of tissue paper and tissue products after wetting. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/25/72524","uuid":"20bb2949-90fd-4771-9daa-2023609f3518","title":"ISO 12625-1:2019 Tissue paper and tissue products — Part 1: Vocabulary","status":"Published","year":2019,"order":11,"text":"This document establishes general principles for the use of terms in the entire working field of tissue paper and tissue products. It permits the use of a common terminology in industry and commerce. It is expressly stated that ISO 15755 applies for the detection of impurities and contraries in tissue paper and tissue products. For the determination of moisture content in tissue paper and tissue products, ISO 287 applies. ","objectID":"72524_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-1:2019 Tissue paper and tissue products — Part 1: Vocabulary","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document establishes general principles for the use of terms in the entire working field of tissue paper and tissue products. It permits the use of a common terminology in industry and commerce. It is expressly stated that <em>ISO</em> 15755 applies for the detection of impurities and contraries in tissue paper and tissue products. For the determination of moisture content in tissue paper and tissue products, <em>ISO</em> 287 applies. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/85/68575","uuid":"648dc254-c4ef-4594-bc3f-896b03e094ef","title":"ISO 12641-2:2019 Graphic technology — Prepress digital data exchange — Part 2: Advanced colour targets for input scanner calibration","status":"Published","year":2019,"order":11,"text":"This document defines a framework for advanced reflective and transmissive layouts and colorimetric values of targets for use in the calibration and characterization of image capturing devices. This document defines a framework for target creation and data reporting. This framework can be used for both ISO defined and custom targets for both reflective and transmissive use. Self-emissive targets are not covered by this document. ","objectID":"68575_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>41-2:2019 Graphic technology — Prepress digital data exchange — Part 2: Advanced colour targets for input scanner calibration","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"This document defines a framework for advanced reflective and transmissive layouts and colorimetric values of targets for use in the calibration and characterization of image capturing devices. This document defines a framework for target creation and data reporting. This framework can be used for both <em>ISO</em> defined and custom targets for both reflective and transmissive use. Self-emissive targets are not covered by this document. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/64/66469","uuid":"82a97dfd-1025-4464-a6d2-8be087628f90","title":"ISO 12625-4:2016 Tissue paper and tissue products — Part 4: Determination of tensile strength, stretch at maximum force and tensile energy absorption","status":"Published","year":2019,"order":11,"text":"ISO 12625-4:2016 specifies a test method for the determination of the tensile strength, stretch at maximum force and tensile energy absorption of tissue paper and tissue products. It uses a tensile-testing apparatus operating with a constant rate of elongation. It also specifies the method of calculating the tensile index and the tensile energy absorption index. In cases where impurities and contraries have to be determined, ISO 15755[6] applies for these detections in tissue paper and tissue products. ","objectID":"66469_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-4:2016 Tissue paper and tissue products — Part 4: Determination of tensile strength, stretch at maximum force and tensile energy absorption","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-4:2016 specifies a test method for the determination of the tensile strength, stretch at maximum force and tensile energy absorption of tissue paper and tissue products. It uses a tensile-testing apparatus operating with a constant rate of elongation. It also specifies the method of calculating the tensile index and the tensile energy absorption index. In cases where impurities and contraries have to be determined, <em>ISO</em> 15755[6] applies for these detections in tissue paper and tissue products. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/25/62536","uuid":"f25a1868-247e-4e15-83bb-39340072b757","title":"ISO 12625-3:2014 Tissue paper and tissue products — Part 3: Determination of thickness, bulking thickness and apparent bulk density and bulk","status":"Published","year":2019,"order":11,"text":"ISO 12625-3:2014 specifies a test method for the determination of thickness and bulking thickness and the calculation of apparent bulk density and bulk of tissue papers and tissue products under a pressure of 2,0 kPa. ","objectID":"62536_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>25-3:2014 Tissue paper and tissue products — Part 3: Determination of thickness, bulking thickness and apparent bulk density and bulk","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>25-3:2014 specifies a test method for the determination of thickness and bulking thickness and the calculation of apparent bulk density and bulk of tissue papers and tissue products under a pressure of 2,0 kPa. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/02/60271","uuid":"2307726e-3073-4f83-957d-4e3de1875270","title":"ISO 12653-3:2014 Electronic imaging — Test target for scanning of office documents — Part 3: Test target for use in lower resolution applications","status":"Published","year":2019,"order":11,"text":"ISO 12653-3:2014 specifies a test target for assessing the consistency of the output quality over time from lower resolution reflection scanning systems. It is applicable to assessing the output quality of black-and-white and colour scanners used for black-and-white or colour office documents, with or without half tone. ","objectID":"60271_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>53-3:2014 Electronic imaging — Test target for scanning of office documents — Part 3: Test target for use in lower resolution applications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>53-3:2014 specifies a test target for assessing the consistency of the output quality over time from lower resolution reflection scanning systems. It is applicable to assessing the output quality of black-and-white and colour scanners used for black-and-white or colour office documents, with or without half tone. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/78/57840","uuid":"96bf4e91-d549-424d-befe-cacaa994581c","title":"ISO 12647-3:2013 Graphic technology — Process control for the production of half-tone colour separations, proofs and production prints — Part 3: Coldset offset lithography on newsprint","status":"Published","year":2019,"order":11,"text":"ISO 12647-3:2013 specifies a number of process parameters and their values to be applied when producing colour separations and printing forms for newspaper single or four-colour printing. The parameters and values are chosen in consideration of the process, covering the process stages: \"colour separation\", \"making of the printing formed\", \"OK print or proof\" and \"production printing\". ISO 12647-3:2013 is intended to enhance communication between printers, publishers and advertisers and to make print buyers aware of the expected printed result in advance, enabling them to plan accordingly. ISO 12647-3:2013 defines tolerances, allowing for objective quality evaluations and raising the competitiveness of newspapers compared to other media. ISO 12647-3:2013 is applicable: to coldset offset production printing on newsprint that use colour separation data; by analogy to press printing from printing surfaces produced by direct imaging; to line screens and non-periodic screens, parameters given can be applied by analogy. ","objectID":"57840_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-3:2013 Graphic technology — Process control for the production of half-tone colour separations, proofs and production prints — Part 3: Coldset offset lithography on newsprint","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>47-3:2013 specifies a number of process parameters and their values to be applied when producing colour separations and printing forms for newspaper single or four-colour printing. The parameters and values are chosen in consideration of the process, covering the process stages: \"colour separation\", \"making of the printing formed\", \"OK print or proof\" and \"production printing\". <em>ISO</em> <em>126</em>47-3:2013 is intended to enhance communication between printers, publishers and advertisers and to make print buyers aware of the expected printed result in advance, enabling them to plan accordingly. <em>ISO</em> <em>126</em>47-3:2013 defines tolerances, allowing for objective quality evaluations and raising the competitiveness of newspapers compared to other media. <em>ISO</em> <em>126</em>47-3:2013 is applicable: to coldset offset production printing on newsprint that use colour separation data; by analogy to press printing from printing surfaces produced by direct imaging; to line screens and non-periodic screens, parameters given can be applied by analogy. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/78/57816","uuid":"3b72f093-9e6d-40d2-acc3-1919d3b3a32b","title":"ISO 12647-1:2013 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 1: Parameters and measurement methods","status":"Published","year":2019,"order":11,"text":"ISO 12647-1:2013 defines and explains the minimum set of primary process control parameters required to uniquely specify the visual characteristics and related technical properties of process-specific production prints and process-independent simulations of fully characterized printing conditions. ","objectID":"57816_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-1:2013 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 1: Parameters and measurement methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>47-1:2013 defines and explains the minimum set of primary process control parameters required to uniquely specify the visual characteristics and related technical properties of process-specific production prints and process-independent simulations of fully characterized printing conditions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/54/55411","uuid":"50e458a5-52ca-46b8-a041-f6a9e4c55afb","title":"ISO 12647-4:2014 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 4: Publication gravure printing","status":"Published","year":2019,"order":11,"text":"ISO 12647-4:2014 specifies a number of process parameters and their values to be applied to four-colour publication gravure printing. The parameters and values are chosen in view of the complete process covering the process stages \"colour separation\", \"making of the printing forme\", \"proof production\", and \"production printing\". ISO 12647-4:2014 is applicable: ?   directly, to publication gravure printing, including magazines, catalogues, and commercial materials, ?   directly, to half-tone and continuous tone proofing processes that predict the colourimetric results of gravure printing, and ?   by analogy, to process-colour gravure package printing. ","objectID":"55411_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>47-4:2014 Graphic technology — Process control for the production of half-tone colour separations, proof and production prints — Part 4: Publication gravure printing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>47-4:2014 specifies a number of process parameters and their values to be applied to four-colour publication gravure printing. The parameters and values are chosen in view of the complete process covering the process stages \"colour separation\", \"making of the printing forme\", \"proof production\", and \"production printing\". <em>ISO</em> <em>126</em>47-4:2014 is applicable: ?   directly, to publication gravure printing, including magazines, catalogues, and commercial materials, ?   directly, to half-tone and continuous tone proofing processes that predict the colourimetric results of gravure printing, and ?   by analogy, to process-colour gravure package printing. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/34/53411","uuid":"75d31dde-6fe2-4d3e-9245-190d352b9c39","title":"ISO 12643-3:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 3: Binding and finishing equipment and systems","status":"Published","year":2019,"order":11,"text":"ISO 12643-3:2010 provides safety requirements specific to binding and finishing equipment and systems. It is intended to be used in conjunction with the general requirements given in ISO 12643-1. ISO 12643-3:2010 provides additional safety requirements for the design and construction of new equipment used to convert printed or blank substrates into cut, folded, collated, assembled, bound, or otherwise finished product. It can also be applicable to processes for preparing substrate for the printing process. It is applicable to a wide range of equipment used in the binding and finishing process. ","objectID":"53411_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>43-3:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 3: Binding and finishing equipment and systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>43-3:2010 provides safety requirements specific to binding and finishing equipment and systems. It is intended to be used in conjunction with the general requirements given in <em>ISO</em> <em>126</em>43-1. <em>ISO</em> <em>126</em>43-3:2010 provides additional safety requirements for the design and construction of new equipment used to convert printed or blank substrates into cut, folded, collated, assembled, bound, or otherwise finished product. It can also be applicable to processes for preparing substrate for the printing process. It is applicable to a wide range of equipment used in the binding and finishing process. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/30/53042","uuid":"61bba24a-f136-4de4-babe-fa12d9d566e0","title":"ISO 12643-2:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 2: Prepress and press equipment and systems","status":"Published","year":2019,"order":11,"text":"ISO 12643-2:2010 provides requirements specific to prepress and press equipment and systems. It is intended to be used in conjunction with the general requirements of ISO 12643-1. ISO 12643-2:2010 provides additional safety requirements for the design and construction of new prepress and press equipment, and the auxiliary equipment integrated into the press control system. ","objectID":"53042_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>43-2:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 2: Prepress and press equipment and systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>43-2:2010 provides requirements specific to prepress and press equipment and systems. It is intended to be used in conjunction with the general requirements of <em>ISO</em> <em>126</em>43-1. <em>ISO</em> <em>126</em>43-2:2010 provides additional safety requirements for the design and construction of new prepress and press equipment, and the auxiliary equipment integrated into the press control system. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/17/51712","uuid":"e81d40a5-df02-4da2-9f81-339b020e0f53","title":"ISO 12643-4:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 4: Converting equipment and systems","status":"Published","year":2019,"order":11,"text":"ISO 12643-4:2010 provides safety requirements for the design and construction of converting equipment used in the package printing, converting and graphic technology industries. It is applicable to converting equipment, not covered by other parts of ISO 12643. It is intended to be used in conjunction with the general requirements given in ISO 12643-1. ","objectID":"51712_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>43-4:2010 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 4: Converting equipment and systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>43-4:2010 provides safety requirements for the design and construction of converting equipment used in the package printing, converting and graphic technology industries. It is applicable to converting equipment, not covered by other parts of <em>ISO</em> <em>126</em>43. It is intended to be used in conjunction with the general requirements given in <em>ISO</em> <em>126</em>43-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/17/51711","uuid":"6713fa4d-b0e9-47b1-9f4c-89300cda07ed","title":"ISO 12643-1:2009 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 1: General requirements","status":"Published","year":2019,"order":11,"text":"ISO 12643-1:2009 provides safety specifications for the design and construction of new equipment used in prepress systems, printing press systems, binding and finishing systems, converting systems and stand‑alone platen presses. It is applicable to equipment used in a stand-alone mode, or in combination with other machines, including ancillary equipment, in which all the machine actuators (e.g. drives) of the equipment are controlled by the same control system. The requirements given in ISO 12643-1:2009 are applicable to the equipment covered by all parts of ISO 12643, unless otherwise noted. ISO 12643-1:2009 is intended to be used in conjunction with the applicable part of ISO 12643 that contains additional requirements specific to a particular type of equipment. ISO 12643-1:2009 addresses recognized significant hazards specific to equipment and systems in the following areas: mechanical; electrical; slipping, tripping, falling; ergonomics; noise; UV and laser radiation; fire and explosion; thermal; other types of emissions [e.g. ozone, ink mist, volatile organic compounds (VOCs), etc.]. The safety principles established in ISO 12643-1:2009 can also be applicable to the design of equipment within areas of technology that are not specified in ISO 12643. ","objectID":"51711_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>43-1:2009 Graphic technology — Safety requirements for graphic technology equipment and systems — Part 1: General requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>43-1:2009 provides safety specifications for the design and construction of new equipment used in prepress systems, printing press systems, binding and finishing systems, converting systems and stand‑alone platen presses. It is applicable to equipment used in a stand-alone mode, or in combination with other machines, including ancillary equipment, in which all the machine actuators (e.g. drives) of the equipment are controlled by the same control system. The requirements given in <em>ISO</em> <em>126</em>43-1:2009 are applicable to the equipment covered by all parts of <em>ISO</em> <em>126</em>43, unless otherwise noted. <em>ISO</em> <em>126</em>43-1:2009 is intended to be used in conjunction with the applicable part of <em>ISO</em> <em>126</em>43 that contains additional requirements specific to a particular type of equipment. <em>ISO</em> <em>126</em>43-1:2009 addresses recognized significant hazards specific to equipment and systems in the following areas: mechanical; electrical; slipping, tripping, falling; ergonomics; noise; UV and laser radiation; fire and explosion; thermal; other types of emissions [e.g. ozone, ink mist, volatile organic compounds (VOCs), etc.]. The safety principles established in <em>ISO</em> <em>126</em>43-1:2009 can also be applicable to the design of equipment within areas of technology that are not specified in <em>ISO</em> <em>126</em>43. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/51/45116","uuid":"ef87e1be-2a68-4a36-a289-61df44d4a2d6","title":"ISO 12640-5:2013 Graphic technology — Prepress digital data exchange — Part 5: Scene-referred standard colour image data (RIMM/SCID)","status":"Published","year":2019,"order":11,"text":"ISO 12640-5:2013 specifies a set of standard scene-referred colour images (encoded as 16-bit RIMM RGB digital data) that can be used to evaluate transforms from a scene-referred image state to an output-referred image state (colour rendering transforms). They can be used for research, testing and assessing colour rendering transforms, in systems such as digital cameras, camera raw processing applications, colour management systems, colour profiles, and output devices such as displays and printers. ","objectID":"45116_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>40-5:2013 Graphic technology — Prepress digital data exchange — Part 5: Scene-referred standard colour image data (RIMM/SCID)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>40-5:2013 specifies a set of standard scene-referred colour images (encoded as 16-bit RIMM RGB digital data) that can be used to evaluate transforms from a scene-referred image state to an output-referred image state (colour rendering transforms). They can be used for research, testing and assessing colour rendering transforms, in systems such as digital cameras, camera raw processing applications, colour management systems, colour profiles, and output devices such as displays and printers. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/03/40359","uuid":"bc945bce-66bf-4bfd-a2ce-f56b0c474c6f","title":"ISO 12615:2004 Bibliographic references and source identifiers for terminology work","status":"Published","year":2019,"order":11,"text":"ISO 12615:2004 applies to the recording, storing and exchange of information on bibliographic sources for terminological work and terminography. It specifies the data elements to be included in bibliographic references for terminology work. These references can be used as data categories in computer applications in terminology or in presenting bibliographies and lists of references accompanying other textual matter, and citations in journal articles. ISO 12615:2004 does not apply to bibliographic descriptions that record and identify documents and are used by librarians, bibliographers and indexers. ISO 12615:2004 also describes source identifiers for different types of bibliographical references and their use. It indicates how the data elements from the bibliographic reference can be reflected in a source identifier, and how its constituent parts can be assembled to provide a unique identifier. ISO 12615:2004 will facilitate the following: identifying, tracing and validating terminological data and other language resources; cross-referencing to documents containing terminological data; data flow management in networking and other cooperative work in terminology documentation and terminography; exchange of terminological data; preparation of technical documents; carrying out of individual projects of terminology and terminography. ","objectID":"40359_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>126</em>15:2004 Bibliographic references and source identifiers for terminology work","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]},"text":{"value":"<em>ISO</em> <em>126</em>15:2004 applies to the recording, storing and exchange of information on bibliographic sources for terminological work and terminography. It specifies the data elements to be included in bibliographic references for terminology work. These references can be used as data categories in computer applications in terminology or in presenting bibliographies and lists of references accompanying other textual matter, and citations in journal articles. <em>ISO</em> <em>126</em>15:2004 does not apply to bibliographic descriptions that record and identify documents and are used by librarians, bibliographers and indexers. <em>ISO</em> <em>126</em>15:2004 also describes source identifiers for different types of bibliographical references and their use. It indicates how the data elements from the bibliographic reference can be reflected in a source identifier, and how its constituent parts can be assembled to provide a unique identifier. <em>ISO</em> <em>126</em>15:2004 will facilitate the following: identifying, tracing and validating terminological data and other language resources; cross-referencing to documents containing terminological data; data flow management in networking and other cooperative work in terminology documentation and terminography; exchange of terminological data; preparation of technical documents; carrying out of individual projects of terminology and terminography. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","126"]}}}],"nbHits":343,"page":0,"nbPages":4,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 126","params":"query=ISO+126&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":4}
256
+ http_version:
257
+ recorded_at: Sat, 09 Oct 2021 16:54:14 GMT
258
+ - request:
259
+ method: get
260
+ uri: https://www.iso.org/contents/data/standard/03/51/35176.html
261
+ body:
262
+ encoding: US-ASCII
263
+ string: ''
264
+ headers:
265
+ Accept-Encoding:
266
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
267
+ Accept:
268
+ - "*/*"
269
+ User-Agent:
270
+ - Ruby
271
+ Host:
272
+ - www.iso.org
273
+ response:
274
+ status:
275
+ code: 301
276
+ message: ''
277
+ headers:
278
+ Expires:
279
+ - Wed, 09 May 1979 05:30:00 GMT
280
+ Cache-Control:
281
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
282
+ Pragma:
283
+ - no-cache
284
+ Set-Cookie:
285
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
286
+ Secure
287
+ - JSESSIONID=EEB8469C4265A7F4E3AFCCC3949CD41E; Path=/; Secure; HttpOnly
288
+ Location:
289
+ - "/standard/35176.html"
290
+ Content-Length:
291
+ - '0'
292
+ Date:
293
+ - Sat, 09 Oct 2021 16:54:15 GMT
294
+ Strict-Transport-Security:
295
+ - max-age=31536000; includeSubDomains
296
+ body:
297
+ encoding: UTF-8
298
+ string: ''
299
+ http_version:
300
+ recorded_at: Sat, 09 Oct 2021 16:54:15 GMT
301
+ - request:
302
+ method: get
303
+ uri: https://www.iso.org/standard/35176.html
304
+ body:
305
+ encoding: US-ASCII
306
+ string: ''
307
+ headers:
308
+ Accept-Encoding:
309
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
310
+ Accept:
311
+ - "*/*"
312
+ User-Agent:
313
+ - Ruby
314
+ Host:
315
+ - www.iso.org
316
+ response:
317
+ status:
318
+ code: 200
319
+ message: ''
320
+ headers:
321
+ Expires:
322
+ - Wed, 09 May 1979 05:30:00 GMT
323
+ Cache-Control:
324
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
325
+ Pragma:
326
+ - no-cache
327
+ Set-Cookie:
328
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
329
+ Secure
330
+ - JSESSIONID=2984EBF579A567AA8106A498D97EC7C5; Path=/; Secure; HttpOnly
331
+ Vary:
332
+ - accept-encoding
333
+ Content-Type:
334
+ - text/html;charset=UTF-8
335
+ Transfer-Encoding:
336
+ - chunked
337
+ Date:
338
+ - Sat, 09 Oct 2021 16:54:17 GMT
339
+ Strict-Transport-Security:
340
+ - max-age=31536000; includeSubDomains
341
+ body:
342
+ encoding: ASCII-8BIT
343
+ string: !binary |-
344
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 126:2005 - Natural rubber latex concentrate — Determination of dry rubber content</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/35176.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20180607" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/03/51/35176.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 126:2005" />
    <meta property="og:title" content="ISO 126:2005" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Natural rubber latex concentrate — Determination of dry rubber content" />
    <meta property="og:description" content="Natural rubber latex concentrate — Determination of dry rubber content" />
    <meta name="description" content="Natural rubber latex concentrate — Determination of dry rubber content" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/35176.html">français</a></li><li><a href="/ru/standard/35176.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="35176 - ISO 126:2005 - Natural rubber latex concentrate — Determination of dry rubber content"></span>

  <span class="hidden" id="itemReference">ISO 126:2005</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">35176</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/83.html">83</a> >&nbsp;<a href="/en/ics/83.040.html">83.040</a> >&nbsp;<a href="/en/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 126:2005</h1>
  <h2 class="no-uppercase">Natural rubber latex concentrate — Determination of dry rubber content</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              This standard was last reviewed and confirmed in&nbsp;2018.
              Therefore this version remains current.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:35176:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>ISO 126:2005 specifies a method for the determination of the dry rubber content of natural rubber latex concentrate.</p>
<p>The method is not necessarily suitable for latices preserved with potassium hydroxide, latices from natural sources other than <i>Hevea brasiliensis</i>, or for compounded latex, vulcanized latex or artificial dispersions of rubber and it is not applicable to synthetic rubber latices.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/03/51/35176.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2005-04</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 5
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 4
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Raw materials (including latex) for use in the rubber industry</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex and raw rubber</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following  <a href="/sdgs.html">Sustainable Development Goals</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG12.html" title="Responsible Consumption and Production">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Responsible Consumption and Production</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/sdg/SDG09.html" title="Industry, Innovation and Infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industry, Innovation and Infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1uAAG~a0fb0000000eX4dAAE~a0cb0000001QYp5AAG" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1uAAG~a0fb0000000eX2DAAU~a0cb0000001QYntAAG" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1zAAG~a0fb0000000eX6YAAU~a0cb0000001QYPsAAO" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1zAAG~a0fb0000000eX0lAAE~a0cb0000001QYpAAAW" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">38</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/25530.html">ISO 126:1995</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 126:2005</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.93</strong> (Confirmed)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#20_00">
                              <span class="stage-code">20.00</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                New project registered in TC/SC work programme
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#20_20">
                              <span class="stage-code">20.20</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                Working draft (WD) study initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#20_99">
                              <span class="stage-code">20.99</span>
                              <span class="stage-date">2001-04-19</span>
                              <div class="stage-title">
                                WD approved for registration as CD
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2001-04-19</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2002-02-27</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2002-04-11</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2002-10-03</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2004-09-22</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2004-10-05</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2004-12-13</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2005-02-18</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2005-02-21</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2005-04-06</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2008-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2008-06-18</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2008-06-30</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2013-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2013-06-19</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2013-07-02</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2018-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2018-06-06</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2018-06-07</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/83.html">83</a></li>
    
      <li><a href="/en/ics/83.040.html">83.040</a></li>
    
      <li><a href="/en/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 126:2005</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
345
+ http_version:
346
+ recorded_at: Sat, 09 Oct 2021 16:54:18 GMT
347
+ - request:
348
+ method: get
349
+ uri: https://www.iso.org/fr/standard/35176.html
350
+ body:
351
+ encoding: US-ASCII
352
+ string: ''
353
+ headers:
354
+ Accept-Encoding:
355
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
356
+ Accept:
357
+ - "*/*"
358
+ User-Agent:
359
+ - Ruby
360
+ Host:
361
+ - www.iso.org
362
+ response:
363
+ status:
364
+ code: 200
365
+ message: ''
366
+ headers:
367
+ Expires:
368
+ - Wed, 09 May 1979 05:30:00 GMT
369
+ Cache-Control:
370
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
371
+ Pragma:
372
+ - no-cache
373
+ Set-Cookie:
374
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
375
+ Secure
376
+ - JSESSIONID=BDA58A879DC1E525FF99BB47BB801991; Path=/; Secure; HttpOnly
377
+ Vary:
378
+ - accept-encoding
379
+ Content-Type:
380
+ - text/html;charset=UTF-8
381
+ Transfer-Encoding:
382
+ - chunked
383
+ Date:
384
+ - Sat, 09 Oct 2021 16:54:20 GMT
385
+ Strict-Transport-Security:
386
+ - max-age=31536000; includeSubDomains
387
+ body:
388
+ encoding: ASCII-8BIT
389
+ string: !binary |-
390
+ <!DOCTYPE html>


<html lang="fr">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'fr'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 126:2005 - Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/fr/standard/35176.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"fr",uilang:"fr",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='fr_FR';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20180607" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/03/51/35176.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 126:2005" />
    <meta property="og:title" content="ISO 126:2005" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec" />
    <meta property="og:description" content="Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec" />
    <meta name="description" content="Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Passer au contenu principal</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/standards.html" class="dropdown-toggle" role="button">Normes</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html" class="dropdown-toggle" role="button">Avantages</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-and-smes.html" class="dropdown-toggle" role="button">PME</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-consumers.html" class="dropdown-toggle" role="button">Consommateurs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-policy-makers.html" class="dropdown-toggle" role="button">L’ISO et les organismes de réglementation</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/standards-in-action.html" class="dropdown-toggle" role="button">Normes en action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html" class="dropdown-toggle" role="button">Les normes les plus connues</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformité</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/the-iso-survey.html" class="dropdown-toggle" role="button">L'Étude ISO</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html" class="dropdown-toggle" role="button">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/about-us.html" class="dropdown-toggle" role="button">À propos de l'ISO</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/what-we-do.html" class="dropdown-toggle" role="button">Nos activités</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/developing-standards.html"  class="dropdown-toggle" role="button">Elaboration des normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/research-and-education.html" class="dropdown-toggle" role="button">Recherche</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/capacity-building.html" class="dropdown-toggle" role="button">Renforcement des capacités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/education-about-standards.html" class="dropdown-toggle" role="button">Enseignement sur les normes</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html" class="dropdown-toggle" role="button">Membres</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/announcements.html" class="dropdown-toggle" role="button">Communiqués</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/fr/strategy2030.html" class="dropdown-toggle" role="button">Stratégie 2030</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Facteurs de changement</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Nos objectifs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Mesurer le succès</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/news.html" class="dropdown-toggle" role="button">Actualités</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html" class="dropdown-toggle" role="button">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html" class="dropdown-toggle" role="button">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/developing-standards.html" class="dropdown-toggle" role="button">Participer</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html" class="dropdown-toggle" role="button">Qui élabore les normes</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/technical-committees.html" class="dropdown-toggle" role="button">Comités techniques</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Autres organismes</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organisations en coopération</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html" class="dropdown-toggle" role="button">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html" class="dropdown-toggle" role="button">Pourquoi s’engager ?</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/fr/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html" class="dropdown-toggle" role="button">Publications et produits</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/fr/#account/products"  target="_blank" class="dropdown-toggle" role="button">Mon compte</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/fr/home.html" title="Organisation internationale de normalisation" alt="Logo ISO"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/fr"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Recherche</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=fr" title="Panier d'achat" aria-label="Panier d'achat">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">FR <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/standard/35176.html">English</a></li><li><a href="/ru/standard/35176.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/news.html">Actualités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="35176 - ISO 126:2005 - Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec"></span>

  <span class="hidden" id="itemReference">ISO 126:2005</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">35176</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="Organisation internationale de normalisation">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/fr/standards-catalogue/browse-by-ics.html"title="Explorez la collection de normes ISO dans son intégralité et trouvez celles qui s’appliquent à votre secteur.">ICS</a> >&nbsp;<a href="/fr/ics/83.html">83</a> >&nbsp;<a href="/fr/ics/83.040.html">83.040</a> >&nbsp;<a href="/fr/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 126:2005</h1>
  <h2 class="no-uppercase">Latex de caoutchouc naturel concentré — Détermination de la teneur en caoutchouc sec</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Acheter cette norme
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              Le dernier examen de cette norme date de&nbsp;2018.
              Cette édition reste donc d’actualité.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Résumé&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:35176:fr">Prévisualiser</a></h3>
          <div itemprop="description">
            <p><p>L'ISO 126:2005 spécifie une méthode de détermination de la teneur en caoutchouc sec du latex de caoutchouc naturel concentré.</p>
<p>La méthode ne convient pas nécessairement pour les latex conservés dans de l'hydroxyde de potassium, pour les latex d'origine naturelle autres que celui de l'<i>Hevea</i> <i>brasiliensis</i> ou pour des mélanges de latex, pour les latex vulcanisés ou les dispersions artificielles de caoutchouc, et elle n'est pas applicable aux latex d'élastomères.</p></p>
          </div>
          <br/>
        <h3>
  Informations générales
  <sup><a href="/fr/contents/data/standard/03/51/35176.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="S'abonner&nbsp;aux&nbsp;mises&nbsp;à&nbsp;jour">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>État actuel&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Publiée"></span>Publiée</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Date de publication&nbsp;: </strong><span itemprop="releaseDate">2005-04</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 5
      </div>
      <div class="col-sm-6">
        
          <strong>Nombre de pages&nbsp;:</strong> 4
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Comité technique</div> :
        <div class="entry-name entry-block">
          <a href="/fr/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Matières premières (y compris le latex) à l'usage de l'industrie des élastomères</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/fr/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex et caoutchouc brut</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/fr/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Objectifs de développement durable" />
      </p>
      <p>
        Cette norme contribue aux  <a href="/fr/sdgs.html">Objectifs de développement durable</a>&nbsp;suivants&nbsp;:
      <p>
      <div class="clearfix">
        
          <a href="/fr/sdg/SDG12.html" title="Consommation et production responsables">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Consommation et production responsables</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/fr/sdg/SDG09.html" title="Industrie, innovation et infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industrie, innovation et infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Acheter&nbsp;cette norme</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">fr</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Langue</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1uAAG~a0fb0000000eX4dAAE~a0cb0000001QYp5AAG" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1uAAG~a0fb0000000eX2DAAU~a0cb0000001QYntAAG" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Papier
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1zAAG~a0fb0000000eX6YAAU~a0cb0000001QYPsAAO" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub00000028F36AAE~a05b0000005WV1zAAG~a0fb0000000eX0lAAE~a0cb0000001QYpAAAW" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">38</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'fr', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Acheter
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Valider mon panier"></span>
            <span id="continueShopping" class="hidden" data-label="Ajouter au panier et continuer mes achats"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Cycle de vie</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Précédemment</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Annulée</div>
                    <h5><a href="/fr/standard/25530.html">ISO 126:1995</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Actuellement</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Publiée</div>
                    
              <h5>ISO 126:2005</h5>
                  <br/>Les normes ISO sont réexaminées tous les cinq ans<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stade: <strong>90.93</strong> (Confirmée)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Préliminaire</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposition</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                Nouveau projet approuvé
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Préparation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#20_00">
                              <span class="stage-code">20.00</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                Nouveau projet enregistré au programme de travail du TC/SC
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#20_20">
                              <span class="stage-code">20.20</span>
                              <span class="stage-date">2000-10-13</span>
                              <div class="stage-title">
                                Mise à l'étude du projet de travail (WD)
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#20_99">
                              <span class="stage-code">20.99</span>
                              <span class="stage-date">2001-04-19</span>
                              <div class="stage-title">
                                WD approuvé pour enregistrement comme CD
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Comité</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2001-04-19</span>
                              <div class="stage-title">
                                CD approuvé pour enregistrement comme DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquête</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2002-02-27</span>
                              <div class="stage-title">
                                DIS enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2002-04-11</span>
                              <div class="stage-title">
                                Mise au vote du DIS:  12 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2002-10-03</span>
                              <div class="stage-title">
                                Clôture du vote
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2004-09-22</span>
                              <div class="stage-title">
                                Rapport complet diffusé: DIS approuvé pour enregistrement comme FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approbation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2004-10-05</span>
                              <div class="stage-title">
                                Texte final reçu ou FDIS enregistré pour approbation formelle
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2004-12-13</span>
                              <div class="stage-title">
                                Epreuve envoyée au secrétariat ou mise au vote du FDIS: 8 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2005-02-18</span>
                              <div class="stage-title">
                                Clôture du vote Epreuve retournée par le secrétariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2005-02-21</span>
                              <div class="stage-title">
                                Norme internationale en cours de publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2005-04-06</span>
                              <div class="stage-title">
                                Norme internationale publiée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Examen</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2008-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2008-06-18</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2008-06-30</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2013-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2013-06-19</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2013-07-02</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2018-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2018-06-06</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2018-06-07</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Annulation</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Vous avez une question?</h4>

<p>Consulter notre&nbsp;<a href="/fr/frequently-asked-questions-faqs.html" title="Foire Aux Questions (FAQs)">FAQ</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Service &agrave; la client&egrave;le</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Horaires d&rsquo;ouverture:<br />
De lundi &agrave; vendredi - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Suivez l&#39;actualit&eacute; de l&#39;ISO</h4>

<p>Inscrivez-vous &agrave; notre Newsletter (en anglais) pour suivre nos actualit&eacute;s, points de vue et informations sur nos produits.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/fr/home.html" title="Page d'accueil"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/fr/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a>

        </li>
      
        <li>
          
              <a href="/fr/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/fr/ics/83.html">83</a></li>
    
      <li><a href="/fr/ics/83.040.html">83.040</a></li>
    
      <li><a href="/fr/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 126:2005</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Plan du site</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html">Avantages</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html">Les normes les plus connues</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/conformity-assessment.html">Certification & conformité</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/what-we-do.html">Nos activités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html">Membres</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030.html">Stratégie 2030</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/news.html">Actualités</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html">Qui élabore les normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html">Pourquoi s’engager ?</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html">Publications et produits</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-name-and-logo.html">Nom et logo de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/privacy-and-copyright.html">Confidentialité et droit d'auteur</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/working-with-iso.html" >Emploi</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/frequently-asked-questions-faqs.html">FAQ</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/contact-iso.html">Contacter l'ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Le monde va loin quand il s'accorde</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">Nous nous engageons à ce que notre site Web soit accessible à tous. Pour toute question ou suggestion concernant l'accessibilité du site, <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contactez-nous</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© Tous droits réservés</a> <span id="copyright" class="collapse">Le matériel publié sur ISO.org est sujet aux mêmes conditions en matière de droits d’auteur que les publications de l’ISO et son emploi est conditionné par l’acceptation, par l’utilisateur, des conditions de l’ISO en matière de droits d’auteur régissant les publications de l’ISO. Toute utilisation du matériel concerné, y compris sa reproduction intégrale ou partielle vers un autre site Internet, requiert l’autorisation écrite de l’ISO. Toute demande à cet effet doit être adressée à <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Retour en haut de page"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression" /></div>
            <div class="poweredby-txt">Développé par</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
391
+ http_version:
392
+ recorded_at: Sat, 09 Oct 2021 16:54:20 GMT
393
+ recorded_with: VCR 5.0.0