<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="oslogin_v1alpha.html">Cloud OS Login API</a> . <a href="oslogin_v1alpha.users.html">users</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="oslogin_v1alpha.users.projects.html">projects()</a></code>
</p>
<p class="firstline">Returns the projects Resource.</p>

<p class="toc_element">
  <code><a href="oslogin_v1alpha.users.sshPublicKeys.html">sshPublicKeys()</a></code>
</p>
<p class="firstline">Returns the sshPublicKeys Resource.</p>

<p class="toc_element">
  <code><a href="#getLoginProfile">getLoginProfile(name, projectId=None, systemId=None, x__xgafv=None, operatingSystemType=None)</a></code></p>
<p class="firstline">Retrieves the profile information used for logging in to a virtual machine</p>
<p class="toc_element">
  <code><a href="#importSshPublicKey">importSshPublicKey(parent, body, projectId=None, x__xgafv=None)</a></code></p>
<p class="firstline">Adds an SSH public key and returns the profile information. Default POSIX</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="getLoginProfile">getLoginProfile(name, projectId=None, systemId=None, x__xgafv=None, operatingSystemType=None)</code>
  <pre>Retrieves the profile information used for logging in to a virtual machine
on Google Compute Engine.

Args:
  name: string, The unique ID for the user in format `users/{user}`. (required)
  projectId: string, The project ID of the Google Cloud Platform project.
  systemId: string, A system ID for filtering the results of the request.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
  operatingSystemType: string, The type of operating system associated with the account.

Returns:
  An object of the form:

    { # The user profile information used for logging in to a virtual machine on
      # Google Compute Engine.
    "posixAccounts": [ # The list of POSIX accounts associated with the user.
      { # The POSIX account information associated with a Google account.
        "username": "A String", # The username of the POSIX account.
        "shell": "A String", # The path to the logic shell for this account.
        "uid": "A String", # The user ID.
        "primary": True or False, # Only one POSIX account can be marked as primary.
        "operatingSystemType": "A String", # The operating system type where this account applies.
        "gid": "A String", # The default group ID.
        "gecos": "A String", # The GECOS (user information) entry for this account.
        "homeDirectory": "A String", # The path to the home directory for this account.
        "systemId": "A String", # System identifier for which account the username or uid applies to.
            # By default, the empty value is used.
        "accountId": "A String", # Output only. A POSIX account identifier.
      },
    ],
    "sshPublicKeys": { # A map from SSH public key fingerprint to the associated key object.
      "a_key": { # The SSH public key information associated with a Google account.
        "expirationTimeUsec": "A String", # An expiration time in microseconds since epoch.
        "key": "A String", # Public key text in SSH format, defined by
            # <a href="https://www.ietf.org/rfc/rfc4253.txt" target="_blank">RFC4253</a>
            # section 6.6.
        "fingerprint": "A String", # Output only. The SHA-256 fingerprint of the SSH public key.
      },
    },
    "name": "A String", # A unique user ID.
  }</pre>
</div>

<div class="method">
    <code class="details" id="importSshPublicKey">importSshPublicKey(parent, body, projectId=None, x__xgafv=None)</code>
  <pre>Adds an SSH public key and returns the profile information. Default POSIX
account information is set when no username and UID exist as part of the
login profile.

Args:
  parent: string, The unique ID for the user in format `users/{user}`. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # The SSH public key information associated with a Google account.
  "expirationTimeUsec": "A String", # An expiration time in microseconds since epoch.
  "key": "A String", # Public key text in SSH format, defined by
      # <a href="https://www.ietf.org/rfc/rfc4253.txt" target="_blank">RFC4253</a>
      # section 6.6.
  "fingerprint": "A String", # Output only. The SHA-256 fingerprint of the SSH public key.
}

  projectId: string, The project ID of the Google Cloud Platform project.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A response message from importing an SSH public key.
    "loginProfile": { # The user profile information used for logging in to a virtual machine on # The login profile information for the user.
        # Google Compute Engine.
      "posixAccounts": [ # The list of POSIX accounts associated with the user.
        { # The POSIX account information associated with a Google account.
          "username": "A String", # The username of the POSIX account.
          "shell": "A String", # The path to the logic shell for this account.
          "uid": "A String", # The user ID.
          "primary": True or False, # Only one POSIX account can be marked as primary.
          "operatingSystemType": "A String", # The operating system type where this account applies.
          "gid": "A String", # The default group ID.
          "gecos": "A String", # The GECOS (user information) entry for this account.
          "homeDirectory": "A String", # The path to the home directory for this account.
          "systemId": "A String", # System identifier for which account the username or uid applies to.
              # By default, the empty value is used.
          "accountId": "A String", # Output only. A POSIX account identifier.
        },
      ],
      "sshPublicKeys": { # A map from SSH public key fingerprint to the associated key object.
        "a_key": { # The SSH public key information associated with a Google account.
          "expirationTimeUsec": "A String", # An expiration time in microseconds since epoch.
          "key": "A String", # Public key text in SSH format, defined by
              # <a href="https://www.ietf.org/rfc/rfc4253.txt" target="_blank">RFC4253</a>
              # section 6.6.
          "fingerprint": "A String", # Output only. The SHA-256 fingerprint of the SSH public key.
        },
      },
      "name": "A String", # A unique user ID.
    },
  }</pre>
</div>

</body></html>