> ## Documentation Index
> Fetch the complete documentation index at: https://docs.formal.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# GetNativeUser



## OpenAPI

````yaml /docs/api/openapi/resource_openapi.json post /core.v1.ResourceService/GetNativeUser
openapi: 3.1.0
info:
  title: core.v1.ResourceService
  version: 0.0.1
servers:
  - url: https://api.joinformal.com
    description: Production API
security: []
tags:
  - name: core.v1.ResourceService
paths:
  /core.v1.ResourceService/GetNativeUser:
    post:
      tags:
        - core.v1.ResourceService
      summary: GetNativeUser
      operationId: core.v1.ResourceService.GetNativeUser
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/core.v1.GetNativeUserRequest'
        required: true
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/core.v1.GetNativeUserResponse'
        '400':
          description: Bad Request - Invalid request parameters or body
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: invalid_request
                  message:
                    type: string
                    example: Invalid request parameters
                  details:
                    type: object
        '401':
          description: Unauthorized - Missing or invalid authentication
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: unauthorized
                  message:
                    type: string
                    example: Authentication required
        '403':
          description: Forbidden - Insufficient permissions
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: forbidden
                  message:
                    type: string
                    example: Insufficient permissions to perform this action
        '404':
          description: Not Found - Resource does not exist
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: not_found
                  message:
                    type: string
                    example: Resource not found
        '500':
          description: Internal Server Error - An error occurred processing the request
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: internal_error
                  message:
                    type: string
                    example: An internal error occurred
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: >-
            curl -X POST
            "https://api.joinformal.com/core.v1.ResourceService/GetNativeUser" \
              -H "X-API-KEY: YOUR_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
                "example": "value"
              }'
        - lang: javascript
          label: JavaScript (fetch)
          source: >-
            fetch("https://api.joinformal.com/core.v1.ResourceService/GetNativeUser",
            {
              method: "POST",
              headers: {
                "X-API-KEY": "YOUR_API_KEY",
                "Content-Type": "application/json"
              },
              body: JSON.stringify({
                example: "value"
              })
            })
              .then(response => response.json())
              .then(data => console.log(data))
              .catch(error => console.error(error));
        - lang: python
          label: Python
          source: >-
            import requests


            url =
            "https://api.joinformal.com/core.v1.ResourceService/GetNativeUser"

            headers = {
                "X-API-KEY": "YOUR_API_KEY",
                "Content-Type": "application/json"
            }

            data = {
                "example": "value"
            }


            response = requests.post(url, headers=headers, json=data)

            print(response.json())
        - lang: go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "encoding/json"
                "fmt"
                "io"
                "net/http"
            )

            func main() {
                url := "https://api.joinformal.com/core.v1.ResourceService/GetNativeUser"

                body := map[string]string{
                    "example": "value",
                }

                jsonData, _ := json.Marshal(body)

                req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
                req.Header.Set("X-API-KEY", "YOUR_API_KEY")
                req.Header.Set("Content-Type", "application/json")

                client := &http.Client{}
                resp, err := client.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()

                responseBody, _ := io.ReadAll(resp.Body)
                fmt.Println(string(responseBody))
            }
components:
  schemas:
    core.v1.GetNativeUserRequest:
      type: object
      properties:
        id:
          type: string
          title: id
          minLength: 1
      title: GetNativeUserRequest
      additionalProperties: false
    core.v1.GetNativeUserResponse:
      type: object
      properties:
        nativeUser:
          $ref: '#/components/schemas/core.v1.NativeUser'
          title: native_user
      title: GetNativeUserResponse
      additionalProperties: false
    core.v1.NativeUser:
      type: object
      properties:
        id:
          type: string
          title: id
          minLength: 1
        resourceId:
          type: string
          title: resource_id
          minLength: 1
        username:
          type: string
          title: username
          description: Old V1 fields for username and secret
        secret:
          type: string
          title: secret
        useAsDefault:
          type: boolean
          title: use_as_default
        terminationProtection:
          type: boolean
          title: termination_protection
        createdAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: created_at
          description: |
            timestamp.lt_now = true
        updatedAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: updated_at
          description: |
            timestamp.lt_now = true
        basic:
          $ref: '#/components/schemas/core.v1.BasicNativeUser'
          title: basic
          description: One of the discriminated union fields - use exactly one
        httpApiKey:
          $ref: '#/components/schemas/core.v1.HTTPAPIKeyNativeUser'
          title: http_api_key
          description: One of the discriminated union fields - use exactly one
        httpBasic:
          $ref: '#/components/schemas/core.v1.HTTPBasicNativeUser'
          title: http_basic
          description: One of the discriminated union fields - use exactly one
        httpBearer:
          $ref: '#/components/schemas/core.v1.HTTPBearerNativeUser'
          title: http_bearer
          description: One of the discriminated union fields - use exactly one
        iam:
          $ref: '#/components/schemas/core.v1.IAMNativeUser'
          title: iam
          description: One of the discriminated union fields - use exactly one
        kubernetes:
          $ref: '#/components/schemas/core.v1.KubernetesNativeUser'
          title: kubernetes
          description: One of the discriminated union fields - use exactly one
        snowflakeKey:
          $ref: '#/components/schemas/core.v1.SnowflakeKeyNativeUser'
          title: snowflake_key
          description: One of the discriminated union fields - use exactly one
        sshKey:
          $ref: '#/components/schemas/core.v1.SSHKeyNativeUser'
          title: ssh_key
          description: One of the discriminated union fields - use exactly one
      title: NativeUser
      additionalProperties: false
      description: >-
        Exactly one of these fields is required: basic or http_api_key or
        http_basic or http_bearer or iam or kubernetes or snowflake_key or
        ssh_key.
    google.protobuf.Timestamp:
      type: string
      examples:
        - '2023-01-15T01:30:15.01Z'
        - '2024-12-25T12:00:00Z'
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();

         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A proto3 JSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a proto3 JSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
    core.v1.BasicNativeUser:
      type: object
      properties:
        username:
          type: string
          title: username
          minLength: 1
        usernameIsEnv:
          type: boolean
          title: username_is_env
        password:
          type: string
          title: password
          minLength: 1
        passwordIsEnv:
          type: boolean
          title: password_is_env
      title: BasicNativeUser
      additionalProperties: false
    core.v1.HTTPAPIKeyNativeUser:
      type: object
      properties:
        location:
          $ref: '#/components/schemas/core.v1.HTTPAPIKeyLocation'
          title: location
        key:
          type: string
          title: key
          minLength: 1
          description: The key is the name of the header or query parameter
        value:
          type: string
          title: value
          minLength: 1
          description: The value is the actual value of the API key
      title: HTTPAPIKeyNativeUser
      additionalProperties: false
    core.v1.HTTPBasicNativeUser:
      type: object
      properties:
        header:
          type: string
          title: header
          minLength: 1
        username:
          type: string
          title: username
          minLength: 1
        password:
          type: string
          title: password
          minLength: 1
      title: HTTPBasicNativeUser
      additionalProperties: false
    core.v1.HTTPBearerNativeUser:
      type: object
      properties:
        header:
          type: string
          title: header
          minLength: 1
        token:
          type: string
          title: token
          minLength: 1
      title: HTTPBearerNativeUser
      additionalProperties: false
    core.v1.IAMNativeUser:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/core.v1.IAMNativeUserType'
          title: type
        role:
          type: string
          title: role
          description: Can be unset if using role inherited from environment
          nullable: true
        username:
          type: string
          title: username
          minLength: 1
      title: IAMNativeUser
      additionalProperties: false
    core.v1.KubernetesNativeUser:
      type: object
      properties:
        kubeconfigEnv:
          type: string
          title: kubeconfig_env
          minLength: 1
          description: Environment variable containing a path to a kubeconfig file
      title: KubernetesNativeUser
      additionalProperties: false
    core.v1.SnowflakeKeyNativeUser:
      type: object
      properties:
        username:
          type: string
          title: username
          minLength: 1
        key:
          type: string
          title: key
          minLength: 1
      title: SnowflakeKeyNativeUser
      additionalProperties: false
    core.v1.SSHKeyNativeUser:
      type: object
      properties:
        username:
          type: string
          title: username
          minLength: 1
        key:
          type: string
          title: key
          minLength: 1
      title: SSHKeyNativeUser
      additionalProperties: false
    core.v1.HTTPAPIKeyLocation:
      type: string
      title: HTTPAPIKeyLocation
      enum:
        - HTTP_API_KEY_LOCATION_HEADER
        - HTTP_API_KEY_LOCATION_QUERY_PARAMETER
    core.v1.IAMNativeUserType:
      type: string
      title: IAMNativeUserType
      enum:
        - IAM_NATIVE_USER_TYPE_AWS
        - IAM_NATIVE_USER_TYPE_GCP
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-API-KEY
      description: API key authentication. Get your API key from the Formal console.

````