:doc:`LexModelBuildingService <../../lex-models>` / Client / get_slot_type

*************
get_slot_type
*************



.. py:method:: LexModelBuildingService.Client.get_slot_type(**kwargs)

  

  Returns information about a specific version of a slot type. In addition to specifying the slot type name, you must specify the slot type version.

   

  This operation requires permissions for the ``lex:GetSlotType`` action.

  

  See also: `AWS API Documentation <https://docs.aws.amazon.com/goto/WebAPI/lex-models-2017-04-19/GetSlotType>`_  


  **Request Syntax**
  ::

    response = client.get_slot_type(
        name='string',
        version='string'
    )
    
  :type name: string
  :param name: **[REQUIRED]** 

    The name of the slot type. The name is case sensitive.

    

  
  :type version: string
  :param version: **[REQUIRED]** 

    The version of the slot type.

    

  
  
  :rtype: dict
  :returns: 
    
    **Response Syntax**

    
    ::

      {
          'name': 'string',
          'description': 'string',
          'enumerationValues': [
              {
                  'value': 'string',
                  'synonyms': [
                      'string',
                  ]
              },
          ],
          'lastUpdatedDate': datetime(2015, 1, 1),
          'createdDate': datetime(2015, 1, 1),
          'version': 'string',
          'checksum': 'string',
          'valueSelectionStrategy': 'ORIGINAL_VALUE'|'TOP_RESOLUTION',
          'parentSlotTypeSignature': 'string',
          'slotTypeConfigurations': [
              {
                  'regexConfiguration': {
                      'pattern': 'string'
                  }
              },
          ]
      }
      
    **Response Structure**

    

    - *(dict) --* 
      

      - **name** *(string) --* 

        The name of the slot type.

        
      

      - **description** *(string) --* 

        A description of the slot type.

        
      

      - **enumerationValues** *(list) --* 

        A list of ``EnumerationValue`` objects that defines the values that the slot type can take.

        
        

        - *(dict) --* 

          Each slot type can have a set of values. Each enumeration value represents a value the slot type can take.

           

          For example, a pizza ordering bot could have a slot type that specifies the type of crust that the pizza should have. The slot type could include the values

           

          
          * thick
           
          * thin
           
          * stuffed
          

          
          

          - **value** *(string) --* 

            The value of the slot type.

            
          

          - **synonyms** *(list) --* 

            Additional values related to the slot type value.

            
            

            - *(string) --* 
        
      
    
      

      - **lastUpdatedDate** *(datetime) --* 

        The date that the slot type was updated. When you create a resource, the creation date and last update date are the same.

        
      

      - **createdDate** *(datetime) --* 

        The date that the slot type was created.

        
      

      - **version** *(string) --* 

        The version of the slot type.

        
      

      - **checksum** *(string) --* 

        Checksum of the ``$LATEST`` version of the slot type.

        
      

      - **valueSelectionStrategy** *(string) --* 

        The strategy that Amazon Lex uses to determine the value of the slot. For more information, see  PutSlotType.

        
      

      - **parentSlotTypeSignature** *(string) --* 

        The built-in slot type used as a parent for the slot type.

        
      

      - **slotTypeConfigurations** *(list) --* 

        Configuration information that extends the parent built-in slot type.

        
        

        - *(dict) --* 

          Provides configuration information for a slot type.

          
          

          - **regexConfiguration** *(dict) --* 

            A regular expression used to validate the value of a slot.

            
            

            - **pattern** *(string) --* 

              A regular expression used to validate the value of a slot.

               

              Use a standard regular expression. Amazon Lex supports the following characters in the regular expression:

               

              
              * A-Z, a-z
               
              * 0-9
               
              * Unicode characters ("\ u<Unicode>")
              

               

              Represent Unicode characters with four digits, for example "\u0041" or "\u005A".

               

              The following regular expression operators are not supported:

               

              
              * Infinite repeaters: *, +, or {x,} with no upper bound.
               
              * Wild card (.)
              

              
        
      
    
  
  **Exceptions**
  
  *   :py:class:`LexModelBuildingService.Client.exceptions.NotFoundException`

  
  *   :py:class:`LexModelBuildingService.Client.exceptions.LimitExceededException`

  
  *   :py:class:`LexModelBuildingService.Client.exceptions.InternalFailureException`

  
  *   :py:class:`LexModelBuildingService.Client.exceptions.BadRequestException`

  

  **Examples**

  This example shows how to get information about a slot type.
  ::

    response = client.get_slot_type(
        version='$LATEST',
        name='DocPizzaCrustType',
    )
    
    print(response)

  
  Expected Output:
  ::

    {
        'version': '$LATEST',
        'name': 'DocPizzaCrustType',
        'checksum': '210b3d5a-90a3-4b22-ac7e-f50c2c71095f',
        'createdDate': 1494359274.403,
        'description': 'Available crust types',
        'enumerationValues': [
            {
                'value': 'thick',
            },
            {
                'value': 'thin',
            },
        ],
        'lastUpdatedDate': 1494359274.403,
        'ResponseMetadata': {
            '...': '...',
        },
    }

  