# Organizations ## CreateOrganization **post** `/gitpod.v1.OrganizationService/CreateOrganization` Creates a new organization with the specified name and settings. Use this method to: - Create a new organization for team collaboration - Set up automatic domain-based invites for team members - Join the organization immediately upon creation ### Examples - Create a basic organization: Creates an organization with just a name. ```yaml name: "Acme Corp Engineering" joinOrganization: true ``` - Create with domain-based invites: Creates an organization that automatically invites users with matching email domains. ```yaml name: "Acme Corp" joinOrganization: true inviteAccountsWithMatchingDomain: true ``` ### Body Parameters - `name: string` name is the organization name - `inviteAccountsWithMatchingDomain: optional boolean` Should other Accounts with the same domain be automatically invited to the organization? - `joinOrganization: optional boolean` join_organization decides whether the Identity issuing this request joins the org on creation ### Returns - `organization: Organization` organization is the created organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization - `member: optional OrganizationMember` member is the member that joined the org on creation. Only set if specified "join_organization" is "true" in the request. - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "name": "Acme Corp Engineering" }' ``` #### Response ```json { "organization": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "name": "name", "tier": "ORGANIZATION_TIER_UNSPECIFIED", "updatedAt": "2019-12-27T18:11:19.117Z", "inviteDomains": { "domains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } }, "member": { "email": "email", "fullName": "fullName", "loginProvider": "loginProvider", "memberSince": "2019-12-27T18:11:19.117Z", "role": "ORGANIZATION_ROLE_UNSPECIFIED", "status": "USER_STATUS_UNSPECIFIED", "userId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "avatarUrl": "avatarUrl" } } ``` ## DeleteOrganization **post** `/gitpod.v1.OrganizationService/DeleteOrganization` Permanently deletes an organization. Use this method to: - Remove unused organizations - Clean up test organizations - Complete organization migration ### Examples - Delete organization: Permanently removes an organization and all its data. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to delete ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/DeleteOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json {} ``` ## JoinOrganization **post** `/gitpod.v1.OrganizationService/JoinOrganization` Allows users to join an organization through direct ID, invite link, or domain-based auto-join. Use this method to: - Join an organization via direct ID or invite - Join automatically based on email domain - Accept organization invitations ### Examples - Join via organization ID: Joins an organization directly when you have the ID. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` - Join via invite: Accepts an organization invitation link. ```yaml inviteId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `inviteId: optional string` invite_id is the unique identifier of the invite to join the organization. - `organizationId: optional string` organization_id is the unique identifier of the Organization to join. ### Returns - `member: OrganizationMember` member is the member that was created by joining the organization. - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/JoinOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{}' ``` #### Response ```json { "member": { "email": "email", "fullName": "fullName", "loginProvider": "loginProvider", "memberSince": "2019-12-27T18:11:19.117Z", "role": "ORGANIZATION_ROLE_UNSPECIFIED", "status": "USER_STATUS_UNSPECIFIED", "userId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "avatarUrl": "avatarUrl" } } ``` ## LeaveOrganization **post** `/gitpod.v1.OrganizationService/LeaveOrganization` Removes a user from an organization while preserving organization data. Use this method to: - Remove yourself from an organization - Clean up inactive memberships - Transfer project ownership before leaving - Manage team transitions ### Examples - Leave organization: Removes user from organization membership. ```yaml userId: "f53d2330-3795-4c5d-a1f3-453121af9c60" ``` Note: Ensure all projects and resources are transferred before leaving. ### Body Parameters - `userId: string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/LeaveOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "userId": "f53d2330-3795-4c5d-a1f3-453121af9c60" }' ``` #### Response ```json {} ``` ## ListMembers **post** `/gitpod.v1.OrganizationService/ListMembers` Lists and filters organization members with optional pagination. Use this method to: - View all organization members - Monitor member activity - Manage team membership ### Examples - List active members: Retrieves active members with pagination. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 20 ``` - List with pagination: Retrieves next page of members. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 50 token: "next-page-token-from-previous-response" ``` ### Query Parameters - `token: optional string` - `pageSize: optional number` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to list members for - `filter: optional object { excludeGroupIds, excludeMembersInAnyTeam, roles, 3 more }` - `excludeGroupIds: optional array of string` exclude_group_ids excludes members who are already in any of the specified groups - `excludeMembersInAnyTeam: optional boolean` exclude_members_in_any_team excludes members who belong to any team in the organization - `roles: optional array of OrganizationRole` roles filters members by their organization role - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `search: optional string` search performs case-insensitive search across member name and email - `statuses: optional array of UserStatus` status filters members by their user status - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userIds: optional array of string` user_ids filters the response to only members with the specified user IDs - `pagination: optional object { token, pageSize }` pagination contains the pagination options for listing members - `token: optional string` Token for the next set of results that was returned as next_token of a PaginationResponse - `pageSize: optional number` Page size is the maximum number of results to retrieve per page. Defaults to 25. Maximum 100. - `sort: optional object { field, order }` sort specifies the order of results. When unspecified, the authenticated user is returned first, followed by other members sorted by name ascending. When an explicit sort is specified, results are sorted purely by the requested field without any special handling for the authenticated user. - `field: optional "SORT_FIELD_UNSPECIFIED" or "SORT_FIELD_NAME" or "SORT_FIELD_DATE_JOINED"` - `"SORT_FIELD_UNSPECIFIED"` - `"SORT_FIELD_NAME"` - `"SORT_FIELD_DATE_JOINED"` - `order: optional SortOrder` - `"SORT_ORDER_UNSPECIFIED"` - `"SORT_ORDER_ASC"` - `"SORT_ORDER_DESC"` ### Returns - `members: array of OrganizationMember` members are the members of the organization - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` - `pagination: object { nextToken }` pagination contains the pagination options for listing members - `nextToken: optional string` Token passed for retrieving the next set of results. Empty if there are no more results ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/ListMembers \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "members": [ { "email": "email", "fullName": "fullName", "loginProvider": "loginProvider", "memberSince": "2019-12-27T18:11:19.117Z", "role": "ORGANIZATION_ROLE_UNSPECIFIED", "status": "USER_STATUS_UNSPECIFIED", "userId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "avatarUrl": "avatarUrl" } ], "pagination": { "nextToken": "nextToken" }, "count": { "relation": "COUNT_RESPONSE_RELATION_UNSPECIFIED", "value": 0 } } ``` ## GetOrganization **post** `/gitpod.v1.OrganizationService/GetOrganization` Gets details about a specific organization. Use this method to: - Retrieve organization settings and configuration - Check organization membership status - View domain verification settings ### Examples - Get organization details: Retrieves information about a specific organization. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the unique identifier of the Organization to retreive. ### Returns - `organization: Organization` organization is the requested organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "organization": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "name": "name", "tier": "ORGANIZATION_TIER_UNSPECIFIED", "updatedAt": "2019-12-27T18:11:19.117Z", "inviteDomains": { "domains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } } } ``` ## SetRole **post** `/gitpod.v1.OrganizationService/SetRole` Manages organization membership and roles by setting a user's role within the organization. Use this method to: - Promote members to admin role - Change member permissions - Demote admins to regular members ### Examples - Promote to admin: Makes a user an organization administrator. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" userId: "f53d2330-3795-4c5d-a1f3-453121af9c60" role: ORGANIZATION_ROLE_ADMIN ``` - Change to member: Changes a user's role to regular member. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" userId: "f53d2330-3795-4c5d-a1f3-453121af9c60" role: ORGANIZATION_ROLE_MEMBER ``` ### Body Parameters - `organizationId: string` - `userId: string` - `role: optional OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/SetRole \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047", "userId": "f53d2330-3795-4c5d-a1f3-453121af9c60" }' ``` #### Response ```json {} ``` ## UpdateOrganization **post** `/gitpod.v1.OrganizationService/UpdateOrganization` Updates an organization's settings including name, invite domains, and member policies. Use this method to: - Modify organization display name - Configure email domain restrictions - Update organization-wide settings - Manage member access policies ### Examples - Update basic settings: Changes organization name and invite domains. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" name: "New Company Name" inviteDomains: domains: - "company.com" - "subsidiary.com" ``` - Remove domain restrictions: Clears all domain-based invite restrictions. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" inviteDomains: domains: [] ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to update the settings for. - `inviteDomains: optional InviteDomains` invite_domains is the domain allowlist of the organization - `domains: optional array of string` domains is the list of domains that are allowed to join the organization - `name: optional string` name is the new name of the organization ### Returns - `organization: Organization` organization is the updated organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateOrganization \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "organization": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "name": "name", "tier": "ORGANIZATION_TIER_UNSPECIFIED", "updatedAt": "2019-12-27T18:11:19.117Z", "inviteDomains": { "domains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } } } ``` ## Domain Types ### Invite Domains - `InviteDomains object { domains }` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization ### Organization - `Organization object { id, createdAt, name, 3 more }` - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization ### Organization Member - `OrganizationMember object { email, fullName, loginProvider, 5 more }` - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` ### Organization Create Response - `OrganizationCreateResponse object { organization, member }` - `organization: Organization` organization is the created organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization - `member: optional OrganizationMember` member is the member that joined the org on creation. Only set if specified "join_organization" is "true" in the request. - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` ### Organization Delete Response - `OrganizationDeleteResponse = unknown` ### Organization Join Response - `OrganizationJoinResponse object { member }` - `member: OrganizationMember` member is the member that was created by joining the organization. - `email: string` - `fullName: string` - `loginProvider: string` login_provider is the login provider the user uses to sign in - `memberSince: string` 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. - `role: OrganizationRole` - `"ORGANIZATION_ROLE_UNSPECIFIED"` - `"ORGANIZATION_ROLE_ADMIN"` - `"ORGANIZATION_ROLE_MEMBER"` - `status: UserStatus` - `"USER_STATUS_UNSPECIFIED"` - `"USER_STATUS_ACTIVE"` - `"USER_STATUS_SUSPENDED"` - `"USER_STATUS_LEFT"` - `userId: string` - `avatarUrl: optional string` ### Organization Leave Response - `OrganizationLeaveResponse = unknown` ### Organization Retrieve Response - `OrganizationRetrieveResponse object { organization }` - `organization: Organization` organization is the requested organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization ### Organization Set Role Response - `OrganizationSetRoleResponse = unknown` ### Organization Update Response - `OrganizationUpdateResponse object { organization }` - `organization: Organization` organization is the updated organization - `id: string` - `createdAt: string` 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. - `name: string` - `tier: OrganizationTier` The tier of the organization - free, enterprise or core - `"ORGANIZATION_TIER_UNSPECIFIED"` - `"ORGANIZATION_TIER_FREE"` - `"ORGANIZATION_TIER_ENTERPRISE"` - `"ORGANIZATION_TIER_CORE"` - `"ORGANIZATION_TIER_FREE_ONA"` - `updatedAt: string` 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. - `inviteDomains: optional InviteDomains` - `domains: optional array of string` domains is the list of domains that are allowed to join the organization # Announcement Banner ## GetAnnouncementBanner **post** `/gitpod.v1.OrganizationService/GetAnnouncementBanner` Retrieves the announcement banner configuration for an organization. Use this method to fetch the current announcement banner settings. All organization members can read the banner configuration. ### Examples - Get announcement banner: ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization ### Returns - `banner: AnnouncementBanner` banner is the announcement banner configuration - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message displayed to users. Supports basic Markdown. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetAnnouncementBanner \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "banner": { "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "enabled": true, "message": "message" } } ``` ## UpdateAnnouncementBanner **post** `/gitpod.v1.OrganizationService/UpdateAnnouncementBanner` Updates the announcement banner configuration for an organization. Use this method to configure the announcement banner displayed to all users. Only organization admins can update the banner. Requires Enterprise tier. ### Examples - Enable announcement banner: ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" message: "Scheduled maintenance on Saturday 10pm-2am UTC" enabled: true ``` - Disable announcement banner: ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" enabled: false ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message. Supports basic Markdown. Maximum 1000 characters. ### Returns - `banner: AnnouncementBanner` banner is the updated announcement banner configuration - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message displayed to users. Supports basic Markdown. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateAnnouncementBanner \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "banner": { "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "enabled": true, "message": "message" } } ``` ## Domain Types ### Announcement Banner - `AnnouncementBanner object { organizationId, enabled, message }` - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message displayed to users. Supports basic Markdown. ### Announcement Banner Get Response - `AnnouncementBannerGetResponse object { banner }` - `banner: AnnouncementBanner` banner is the announcement banner configuration - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message displayed to users. Supports basic Markdown. ### Announcement Banner Update Response - `AnnouncementBannerUpdateResponse object { banner }` - `banner: AnnouncementBanner` banner is the updated announcement banner configuration - `organizationId: string` organization_id is the ID of the organization - `enabled: optional boolean` enabled controls whether the banner is displayed - `message: optional string` message is the banner message displayed to users. Supports basic Markdown. # Custom Domains ## CreateCustomDomain **post** `/gitpod.v1.OrganizationService/CreateCustomDomain` Creates a custom domain configuration for an organization. Use this method to configure custom domains for organization workspaces ### Examples - Configure AWS custom domain: Sets up a custom domain with AWS provider. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" domainName: "workspaces.acme-corp.com" provider: CUSTOM_DOMAIN_PROVIDER_AWS awsAccountId: "123456789012" ``` ### Body Parameters - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization to create the custom domain for - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Returns - `customDomain: CustomDomain` custom_domain is the created custom domain - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateCustomDomain \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domainName": "workspaces.acme-corp.com", "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "customDomain": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "domainName": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "updatedAt": "2019-12-27T18:11:19.117Z", "awsAccountId": "awsAccountId", "cloudAccountId": "cloudAccountId", "provider": "CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED" } } ``` ## DeleteCustomDomain **post** `/gitpod.v1.OrganizationService/DeleteCustomDomain` Removes a custom domain configuration from an organization. Use this method to: - Disable custom domain functionality - Remove outdated configurations - Clean up unused domains ### Examples - Delete custom domain configuration: Removes a specific custom domain configuration. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to delete custom domain for ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/DeleteCustomDomain \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json {} ``` ## GetCustomDomain **post** `/gitpod.v1.OrganizationService/GetCustomDomain` Retrieves a specific custom domain configuration. Use this method to view custom domain details ### Examples - Get custom domain configuration: Retrieves details of a specific custom domain. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to retrieve custom domain for ### Returns - `customDomain: CustomDomain` CustomDomain represents a custom domain configuration for an organization - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetCustomDomain \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "customDomain": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "domainName": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "updatedAt": "2019-12-27T18:11:19.117Z", "awsAccountId": "awsAccountId", "cloudAccountId": "cloudAccountId", "provider": "CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED" } } ``` ## UpdateCustomDomain **post** `/gitpod.v1.OrganizationService/UpdateCustomDomain` Updates custom domain configuration settings. Use this method to: - Update cloud provider settings - Change AWS account ID - Modify domain configuration ### Examples - Update AWS account ID: Changes the AWS account ID for the custom domain. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" domainName: "workspaces.acme-corp.com" awsAccountId: "987654321098" ``` ### Body Parameters - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization to update custom domain for - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Returns - `customDomain: CustomDomain` custom_domain is the updated custom domain - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateCustomDomain \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domainName": "workspaces.acme-corp.com", "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "customDomain": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "domainName": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "updatedAt": "2019-12-27T18:11:19.117Z", "awsAccountId": "awsAccountId", "cloudAccountId": "cloudAccountId", "provider": "CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED" } } ``` ## Domain Types ### Custom Domain - `CustomDomain object { id, createdAt, domainName, 5 more }` CustomDomain represents a custom domain configuration for an organization - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Custom Domain Provider - `CustomDomainProvider = "CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED" or "CUSTOM_DOMAIN_PROVIDER_AWS" or "CUSTOM_DOMAIN_PROVIDER_GCP"` CustomDomainProvider represents the cloud provider for custom domain configuration - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Custom Domain Create Response - `CustomDomainCreateResponse object { customDomain }` CreateCustomDomainResponse is the response message for creating a custom domain - `customDomain: CustomDomain` custom_domain is the created custom domain - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Custom Domain Delete Response - `CustomDomainDeleteResponse = unknown` DeleteCustomDomainResponse is the response message for deleting a custom domain ### Custom Domain Retrieve Response - `CustomDomainRetrieveResponse object { customDomain }` - `customDomain: CustomDomain` CustomDomain represents a custom domain configuration for an organization - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` ### Custom Domain Update Response - `CustomDomainUpdateResponse object { customDomain }` UpdateCustomDomainResponse is the response message for updating a custom domain - `customDomain: CustomDomain` custom_domain is the updated custom domain - `id: string` id is the unique identifier of the custom domain - `createdAt: string` created_at is when the custom domain was created - `domainName: string` domain_name is the custom domain name - `organizationId: string` organization_id is the ID of the organization this custom domain belongs to - `updatedAt: string` updated_at is when the custom domain was last updated - `awsAccountId: optional string` aws_account_id is the AWS account ID (deprecated: use cloud_account_id) - `cloudAccountId: optional string` cloud_account_id is the unified cloud account identifier (AWS Account ID or GCP Project ID) - `provider: optional CustomDomainProvider` provider is the cloud provider for this custom domain - `"CUSTOM_DOMAIN_PROVIDER_UNSPECIFIED"` - `"CUSTOM_DOMAIN_PROVIDER_AWS"` - `"CUSTOM_DOMAIN_PROVIDER_GCP"` # Domain Verifications ## CreateDomainVerification **post** `/gitpod.v1.OrganizationService/CreateDomainVerification` Initiates domain verification process to enable organization features. Use this method to: - Start domain ownership verification - Enable automatic team joining - Set up SSO restrictions - Configure email-based policies ### Examples - Verify primary domain: Starts verification for main company domain. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" domain: "acme-corp.com" ``` - Verify subsidiary domain: Adds verification for additional company domain. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" domain: "acme-subsidiary.com" ``` ### Body Parameters - `domain: string` - `organizationId: string` ### Returns - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateDomainVerification \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domain": "acme-corp.com", "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "domainVerification": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "domain": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "state": "DOMAIN_VERIFICATION_STATE_UNSPECIFIED", "createdAt": "2019-12-27T18:11:19.117Z", "verificationToken": "verificationToken", "verifiedAt": "2019-12-27T18:11:19.117Z" } } ``` ## DeleteDomainVerification **post** `/gitpod.v1.OrganizationService/DeleteDomainVerification` Removes a domain verification request. Use this method to: - Cancel pending verifications - Remove verified domains - Clean up unused domain records ### Examples - Delete verification: Removes a domain verification request. ```yaml domainVerificationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `domainVerificationId: string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/DeleteDomainVerification \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domainVerificationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json {} ``` ## ListDomainVerifications **post** `/gitpod.v1.OrganizationService/ListDomainVerifications` Lists and monitors domain verification status across an organization. Use this method to: - Track verification progress - View all verified domains - Monitor pending verifications - Audit domain settings ### Examples - List all verifications: Shows all domain verifications regardless of status. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 20 ``` - List with pagination: Retrieves next page of verifications. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 20 token: "next-page-token-from-previous-response" ``` ### Query Parameters - `token: optional string` - `pageSize: optional number` ### Body Parameters - `organizationId: string` - `pagination: optional object { token, pageSize }` - `token: optional string` Token for the next set of results that was returned as next_token of a PaginationResponse - `pageSize: optional number` Page size is the maximum number of results to retrieve per page. Defaults to 25. Maximum 100. ### Returns - `pagination: object { nextToken }` - `nextToken: optional string` Token passed for retrieving the next set of results. Empty if there are no more results - `domainVerifications: optional array of DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/ListDomainVerifications \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "pagination": { "nextToken": "nextToken" }, "domainVerifications": [ { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "domain": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "state": "DOMAIN_VERIFICATION_STATE_UNSPECIFIED", "createdAt": "2019-12-27T18:11:19.117Z", "verificationToken": "verificationToken", "verifiedAt": "2019-12-27T18:11:19.117Z" } ] } ``` ## GetDomainVerification **post** `/gitpod.v1.OrganizationService/GetDomainVerification` Retrieves the status of a domain verification request. Use this method to: - Check verification progress - View verification requirements - Monitor domain status ### Examples - Get verification status: Checks the current state of a domain verification. ```yaml domainVerificationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `domainVerificationId: string` ### Returns - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetDomainVerification \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domainVerificationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "domainVerification": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "domain": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "state": "DOMAIN_VERIFICATION_STATE_UNSPECIFIED", "createdAt": "2019-12-27T18:11:19.117Z", "verificationToken": "verificationToken", "verifiedAt": "2019-12-27T18:11:19.117Z" } } ``` ## VerifyDomain **post** `/gitpod.v1.OrganizationService/VerifyDomain` Verifies domain ownership for an organization. Use this method to: - Complete domain verification process - Enable domain-based features - Validate DNS configuration ### Examples - Verify domain ownership: Verifies ownership after DNS records are configured. ```yaml domainVerificationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `domainVerificationId: string` ### Returns - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/VerifyDomain \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "domainVerificationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "domainVerification": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "domain": "xxxx", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "state": "DOMAIN_VERIFICATION_STATE_UNSPECIFIED", "createdAt": "2019-12-27T18:11:19.117Z", "verificationToken": "verificationToken", "verifiedAt": "2019-12-27T18:11:19.117Z" } } ``` ## Domain Types ### Domain Verification - `DomainVerification object { id, domain, organizationId, 4 more }` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Domain Verification State - `DomainVerificationState = "DOMAIN_VERIFICATION_STATE_UNSPECIFIED" or "DOMAIN_VERIFICATION_STATE_PENDING" or "DOMAIN_VERIFICATION_STATE_VERIFIED"` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` ### Domain Verification Create Response - `DomainVerificationCreateResponse object { domainVerification }` - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Domain Verification Delete Response - `DomainVerificationDeleteResponse = unknown` ### Domain Verification Retrieve Response - `DomainVerificationRetrieveResponse object { domainVerification }` - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. ### Domain Verification Verify Response - `DomainVerificationVerifyResponse object { domainVerification }` - `domainVerification: DomainVerification` - `id: string` - `domain: string` - `organizationId: string` - `state: DomainVerificationState` - `"DOMAIN_VERIFICATION_STATE_UNSPECIFIED"` - `"DOMAIN_VERIFICATION_STATE_PENDING"` - `"DOMAIN_VERIFICATION_STATE_VERIFIED"` - `createdAt: optional string` 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. - `verificationToken: optional string` - `verifiedAt: optional string` 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. # Invites ## CreateOrganizationInvite **post** `/gitpod.v1.OrganizationService/CreateOrganizationInvite` Creates an invite link for joining an organization. Any existing OrganizationInvites are invalidated and can no longer be used. Use this method to: - Generate shareable invite links - Manage team growth - Control organization access ### Examples - Create organization invite: Generates a new invite link for the organization. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` ### Returns - `invite: OrganizationInvite` - `inviteId: string` invite_id is the unique identifier of the invite to join the organization. Use JoinOrganization with this ID to join the organization. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateOrganizationInvite \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "invite": { "inviteId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" } } ``` ## GetOrganizationInviteSummary **post** `/gitpod.v1.OrganizationService/GetOrganizationInviteSummary` Retrieves organization details and membership info based on an invite link. Use this method to: - Preview organization details before joining - Validate invite link authenticity - Check organization size and activity - View team information before accepting ### Examples - Get invite summary: Retrieves organization information from an invite. ```yaml inviteId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `inviteId: string` ### Returns - `organizationId: string` - `organizationMemberCount: optional number` - `organizationName: optional string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetOrganizationInviteSummary \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "inviteId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "organizationMemberCount": 0, "organizationName": "organizationName" } ``` ## GetOrganizationInvite **post** `/gitpod.v1.OrganizationService/GetOrganizationInvite` GetOrganizationInvite ### Body Parameters - `organizationId: string` ### Returns - `invite: OrganizationInvite` - `inviteId: string` invite_id is the unique identifier of the invite to join the organization. Use JoinOrganization with this ID to join the organization. ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetOrganizationInvite \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" }' ``` #### Response ```json { "invite": { "inviteId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" } } ``` ## Domain Types ### Organization Invite - `OrganizationInvite object { inviteId }` - `inviteId: string` invite_id is the unique identifier of the invite to join the organization. Use JoinOrganization with this ID to join the organization. ### Invite Create Response - `InviteCreateResponse object { invite }` - `invite: OrganizationInvite` - `inviteId: string` invite_id is the unique identifier of the invite to join the organization. Use JoinOrganization with this ID to join the organization. ### Invite Get Summary Response - `InviteGetSummaryResponse object { organizationId, organizationMemberCount, organizationName }` - `organizationId: string` - `organizationMemberCount: optional number` - `organizationName: optional string` ### Invite Retrieve Response - `InviteRetrieveResponse object { invite }` - `invite: OrganizationInvite` - `inviteId: string` invite_id is the unique identifier of the invite to join the organization. Use JoinOrganization with this ID to join the organization. # Policies ## GetOrganizationPolicies **post** `/gitpod.v1.OrganizationService/GetOrganizationPolicies` Gets organization policy settings by organization ID. Use this method to: - Retrieve current policy settings for an organization - View resource limits and restrictions - Check allowed editors and other configurations ### Examples - Get organization policies: Retrieves policy settings for a specific organization. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to retrieve policies for ### Returns - `policies: OrganizationPolicies` - `agentPolicy: AgentPolicy` agent_policy contains agent-specific policy settings - `commandDenyList: array of string` command_deny_list contains a list of commands that agents are not allowed to execute - `mcpDisabled: boolean` mcp_disabled controls whether MCP (Model Context Protocol) is disabled for agents - `scmToolsDisabled: boolean` scm_tools_disabled controls whether SCM (Source Control Management) tools are disabled for agents - `conversationSharingPolicy: optional ConversationSharingPolicy` conversation_sharing_policy controls whether agent conversations can be shared - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` - `maxSubagentsPerEnvironment: optional number` max_subagents_per_environment limits the number of non-terminal sub-agents a parent can have running simultaneously in the same environment. Valid range: 0-10. Zero means use the default (5). - `scmToolsAllowedGroupId: optional string` scm_tools_allowed_group_id restricts SCM tools access to members of this group. Empty means no restriction (all users can use SCM tools if not disabled). - `allowedEditorIds: array of string` allowed_editor_ids is the list of editor IDs that are allowed to be used in the organization - `allowLocalRunners: boolean` allow_local_runners controls whether local runners are allowed to be used in the organization - `defaultEditorId: string` default_editor_id is the default editor ID to be used when a user doesn't specify one - `defaultEnvironmentImage: string` default_environment_image is the default container image when none is defined in repo - `maximumEnvironmentsPerUser: string` maximum_environments_per_user limits total environments (running or stopped) per user - `maximumRunningEnvironmentsPerUser: string` maximum_running_environments_per_user limits simultaneously running environments per user - `membersCreateProjects: boolean` members_create_projects controls whether members can create projects - `membersRequireProjects: boolean` members_require_projects controls whether environments can only be created from projects by non-admin users - `organizationId: string` organization_id is the ID of the organization - `portSharingDisabled: boolean` port_sharing_disabled controls whether user-initiated port sharing is disabled in the organization. System ports (VS Code Browser, agents) are always exempt from this policy. - `requireCustomDomainAccess: boolean` require_custom_domain_access controls whether users must access via custom domain when one is configured. When true, access via app.gitpod.io is blocked. - `restrictAccountCreationToScim: boolean` restrict_account_creation_to_scim controls whether account creation is restricted to SCIM-provisioned users only. When true and SCIM is configured for the organization, only users provisioned via SCIM can create accounts. - `deleteArchivedEnvironmentsAfter: optional string` delete_archived_environments_after controls how long archived environments are kept before automatic deletion. 0 means no automatic deletion. Maximum duration is 4 weeks (2419200 seconds). - `editorVersionRestrictions: optional map[object { allowedVersions } ]` editor_version_restrictions restricts which editor versions can be used. Maps editor ID to version policy, editor_version_restrictions not set means no restrictions. If empty or not set for an editor, we will use the latest version of the editor - `allowedVersions: optional array of string` allowed_versions lists the versions that are allowed If empty, we will use the latest version of the editor Examples for JetBrains: `["2025.2", "2025.1", "2024.3"]` - `maximumEnvironmentLifetime: optional string` maximum_environment_lifetime controls for how long environments are allowed to be reused. 0 means no maximum lifetime. Maximum duration is 180 days (15552000 seconds). - `maximumEnvironmentTimeout: optional string` maximum_environment_timeout controls the maximum timeout allowed for environments in seconds. 0 means no limit (never). Minimum duration is 30 minutes (1800 seconds). value must be 0s (no limit) or at least 1800s (30 minutes): ``` this == duration('0s') || this >= duration('1800s') ``` - `securityAgentPolicy: optional SecurityAgentPolicy` security_agent_policy contains security agent configuration for the organization. When configured, security agents are automatically deployed to all environments. - `crowdstrike: optional CrowdStrikeConfig` crowdstrike contains CrowdStrike Falcon configuration - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs. Keys should NOT include the FALCONCTL_OPT_ prefix. - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID). - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor (comma-separated) - `vetoExecPolicy: optional VetoExecPolicy` veto_exec_policy contains the veto exec policy for environments. - `action: optional KernelControlsAction` action specifies what action kernel-level controls take on policy violations - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` - `enabled: optional boolean` enabled controls whether executable blocking is active - `executables: optional array of string` executables is the list of executable paths or names to block ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetOrganizationPolicies \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "policies": { "agentPolicy": { "commandDenyList": [ "string" ], "mcpDisabled": true, "scmToolsDisabled": true, "conversationSharingPolicy": "CONVERSATION_SHARING_POLICY_UNSPECIFIED", "maxSubagentsPerEnvironment": 10, "scmToolsAllowedGroupId": "scmToolsAllowedGroupId" }, "allowedEditorIds": [ "string" ], "allowLocalRunners": true, "defaultEditorId": "defaultEditorId", "defaultEnvironmentImage": "defaultEnvironmentImage", "maximumEnvironmentsPerUser": "maximumEnvironmentsPerUser", "maximumRunningEnvironmentsPerUser": "maximumRunningEnvironmentsPerUser", "membersCreateProjects": true, "membersRequireProjects": true, "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "portSharingDisabled": true, "requireCustomDomainAccess": true, "restrictAccountCreationToScim": true, "deleteArchivedEnvironmentsAfter": "+9125115.360s", "editorVersionRestrictions": { "foo": { "allowedVersions": [ "string" ] } }, "maximumEnvironmentLifetime": "+9125115.360s", "maximumEnvironmentLifetimeStrict": true, "maximumEnvironmentTimeout": "+9125115.360s", "securityAgentPolicy": { "crowdstrike": { "additionalOptions": { "foo": "string" }, "cidSecretId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "enabled": true, "image": "image", "tags": "tags" }, "customAgents": [ { "id": "id", "description": "description", "enabled": true, "envMappings": [ { "name": "name", "secretName": "secretName" } ], "name": "name", "startCommand": "startCommand" } ] }, "vetoExecPolicy": { "action": "KERNEL_CONTROLS_ACTION_UNSPECIFIED", "enabled": true, "executables": [ "string" ], "safelist": [ "string" ] } } } ``` ## UpdateOrganizationPolicies **post** `/gitpod.v1.OrganizationService/UpdateOrganizationPolicies` Updates organization policy settings. Use this method to: - Configure editor restrictions - Set environment resource limits - Define project creation permissions - Customize default configurations ### Examples - Update editor policies: Restricts available editors and sets a default. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" allowedEditorIds: - "vscode" - "jetbrains" defaultEditorId: "vscode" ``` - Set environment limits: Configures limits for environment usage. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" maximumEnvironmentTimeout: "3600s" maximumRunningEnvironmentsPerUser: "5" maximumEnvironmentsPerUser: "20" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to update policies for - `agentPolicy: optional object { commandDenyList, conversationSharingPolicy, maxSubagentsPerEnvironment, 3 more }` agent_policy contains agent-specific policy settings - `commandDenyList: optional array of string` command_deny_list contains a list of commands that agents are not allowed to execute - `conversationSharingPolicy: optional ConversationSharingPolicy` conversation_sharing_policy controls whether agent conversations can be shared - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` - `maxSubagentsPerEnvironment: optional number` max_subagents_per_environment limits the number of non-terminal sub-agents a parent can have running simultaneously in the same environment. Valid range: 0-10. Zero means use the default (5). - `mcpDisabled: optional boolean` mcp_disabled controls whether MCP (Model Context Protocol) is disabled for agents - `scmToolsAllowedGroupId: optional string` scm_tools_allowed_group_id restricts SCM tools access to members of this group. Empty means no restriction (all users can use SCM tools if not disabled). - `scmToolsDisabled: optional boolean` scm_tools_disabled controls whether SCM (Source Control Management) tools are disabled for agents - `allowedEditorIds: optional array of string` allowed_editor_ids is the list of editor IDs that are allowed to be used in the organization - `allowLocalRunners: optional boolean` allow_local_runners controls whether local runners are allowed to be used in the organization - `defaultEditorId: optional string` default_editor_id is the default editor ID to be used when a user doesn't specify one - `defaultEnvironmentImage: optional string` default_environment_image is the default container image when none is defined in repo - `deleteArchivedEnvironmentsAfter: optional string` delete_archived_environments_after controls how long archived environments are kept before automatic deletion. 0 means no automatic deletion. Maximum duration is 4 weeks (2419200 seconds). - `editorVersionRestrictions: optional map[object { allowedVersions } ]` editor_version_restrictions restricts which editor versions can be used. Maps editor ID to version policy with allowed major versions. - `allowedVersions: optional array of string` allowed_versions lists the versions that are allowed If empty, we will use the latest version of the editor Examples for JetBrains: `["2025.2", "2025.1", "2024.3"]` - `maximumEnvironmentLifetime: optional string` maximum_environment_lifetime controls for how long environments are allowed to be reused. 0 means no maximum lifetime. Maximum duration is 180 days (15552000 seconds). - `maximumEnvironmentsPerUser: optional string` maximum_environments_per_user limits total environments (running or stopped) per user - `maximumEnvironmentTimeout: optional string` maximum_environment_timeout controls the maximum timeout allowed for environments in seconds. 0 means no limit (never). Minimum duration is 30 minutes (1800 seconds). value must be 0s (no limit) or at least 1800s (30 minutes): ``` this == duration('0s') || this >= duration('1800s') ``` - `maximumRunningEnvironmentsPerUser: optional string` maximum_running_environments_per_user limits simultaneously running environments per user - `membersCreateProjects: optional boolean` members_create_projects controls whether members can create projects - `membersRequireProjects: optional boolean` members_require_projects controls whether environments can only be created from projects by non-admin users - `portSharingDisabled: optional boolean` port_sharing_disabled controls whether user-initiated port sharing is disabled in the organization. System ports (VS Code Browser, agents) are always exempt from this policy. - `requireCustomDomainAccess: optional boolean` require_custom_domain_access controls whether users must access via custom domain when one is configured. When true, access via app.gitpod.io is blocked. - `restrictAccountCreationToScim: optional boolean` restrict_account_creation_to_scim controls whether account creation is restricted to SCIM-provisioned users only. When true and SCIM is configured for the organization, only users provisioned via SCIM can create accounts. - `securityAgentPolicy: optional object { crowdstrike }` security_agent_policy contains security agent configuration updates - `crowdstrike: optional object { additionalOptions, cidSecretId, enabled, 2 more }` crowdstrike contains CrowdStrike Falcon configuration updates - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID) - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor - `vetoExecPolicy: optional VetoExecPolicy` veto_exec_policy contains the veto exec policy for environments. - `action: optional KernelControlsAction` action specifies what action kernel-level controls take on policy violations - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` - `enabled: optional boolean` enabled controls whether executable blocking is active - `executables: optional array of string` executables is the list of executable paths or names to block ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateOrganizationPolicies \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json {} ``` ## Domain Types ### Agent Policy - `AgentPolicy object { commandDenyList, mcpDisabled, scmToolsDisabled, 3 more }` AgentPolicy contains agent-specific policy settings for an organization - `commandDenyList: array of string` command_deny_list contains a list of commands that agents are not allowed to execute - `mcpDisabled: boolean` mcp_disabled controls whether MCP (Model Context Protocol) is disabled for agents - `scmToolsDisabled: boolean` scm_tools_disabled controls whether SCM (Source Control Management) tools are disabled for agents - `conversationSharingPolicy: optional ConversationSharingPolicy` conversation_sharing_policy controls whether agent conversations can be shared - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` - `maxSubagentsPerEnvironment: optional number` max_subagents_per_environment limits the number of non-terminal sub-agents a parent can have running simultaneously in the same environment. Valid range: 0-10. Zero means use the default (5). - `scmToolsAllowedGroupId: optional string` scm_tools_allowed_group_id restricts SCM tools access to members of this group. Empty means no restriction (all users can use SCM tools if not disabled). ### Conversation Sharing Policy - `ConversationSharingPolicy = "CONVERSATION_SHARING_POLICY_UNSPECIFIED" or "CONVERSATION_SHARING_POLICY_DISABLED" or "CONVERSATION_SHARING_POLICY_ORGANIZATION"` ConversationSharingPolicy controls how agent conversations can be shared. - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` ### Crowd Strike Config - `CrowdStrikeConfig object { additionalOptions, cidSecretId, enabled, 2 more }` CrowdStrikeConfig configures CrowdStrike Falcon sensor deployment - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs. Keys should NOT include the FALCONCTL_OPT_ prefix. - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID). - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor (comma-separated) ### Custom Agent Env Mapping - `CustomAgentEnvMapping object { name, secretName }` CustomAgentEnvMapping maps a script placeholder to an organization secret. The backend resolves the secret name to a UUID at runtime. - `name: optional string` name is the environment variable name used as a placeholder in the start command. - `secretName: optional string` secret_name is the name of the organization secret whose value populates this placeholder. ### Custom Security Agent - `CustomSecurityAgent object { id, description, enabled, 3 more }` CustomSecurityAgent defines a custom security agent configured by an organization admin. - `id: optional string` id is a unique identifier for this custom agent within the organization. Server-generated at save time if empty. - `description: optional string` description is a human-readable description of what this agent does - `enabled: optional boolean` enabled controls whether this custom agent is deployed to environments - `envMappings: optional array of CustomAgentEnvMapping` env_mappings maps script placeholders to organization secret names, resolved to secret values at runtime. - `name: optional string` name is the environment variable name used as a placeholder in the start command. - `secretName: optional string` secret_name is the name of the organization secret whose value populates this placeholder. - `name: optional string` name is the display name for this custom agent - `startCommand: optional string` start_command is the shell script that starts the agent ### Kernel Controls Action - `KernelControlsAction = "KERNEL_CONTROLS_ACTION_UNSPECIFIED" or "KERNEL_CONTROLS_ACTION_BLOCK" or "KERNEL_CONTROLS_ACTION_AUDIT"` KernelControlsAction defines how a kernel-level policy violation is handled. - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` ### Organization Policies - `OrganizationPolicies object { agentPolicy, allowedEditorIds, allowLocalRunners, 16 more }` - `agentPolicy: AgentPolicy` agent_policy contains agent-specific policy settings - `commandDenyList: array of string` command_deny_list contains a list of commands that agents are not allowed to execute - `mcpDisabled: boolean` mcp_disabled controls whether MCP (Model Context Protocol) is disabled for agents - `scmToolsDisabled: boolean` scm_tools_disabled controls whether SCM (Source Control Management) tools are disabled for agents - `conversationSharingPolicy: optional ConversationSharingPolicy` conversation_sharing_policy controls whether agent conversations can be shared - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` - `maxSubagentsPerEnvironment: optional number` max_subagents_per_environment limits the number of non-terminal sub-agents a parent can have running simultaneously in the same environment. Valid range: 0-10. Zero means use the default (5). - `scmToolsAllowedGroupId: optional string` scm_tools_allowed_group_id restricts SCM tools access to members of this group. Empty means no restriction (all users can use SCM tools if not disabled). - `allowedEditorIds: array of string` allowed_editor_ids is the list of editor IDs that are allowed to be used in the organization - `allowLocalRunners: boolean` allow_local_runners controls whether local runners are allowed to be used in the organization - `defaultEditorId: string` default_editor_id is the default editor ID to be used when a user doesn't specify one - `defaultEnvironmentImage: string` default_environment_image is the default container image when none is defined in repo - `maximumEnvironmentsPerUser: string` maximum_environments_per_user limits total environments (running or stopped) per user - `maximumRunningEnvironmentsPerUser: string` maximum_running_environments_per_user limits simultaneously running environments per user - `membersCreateProjects: boolean` members_create_projects controls whether members can create projects - `membersRequireProjects: boolean` members_require_projects controls whether environments can only be created from projects by non-admin users - `organizationId: string` organization_id is the ID of the organization - `portSharingDisabled: boolean` port_sharing_disabled controls whether user-initiated port sharing is disabled in the organization. System ports (VS Code Browser, agents) are always exempt from this policy. - `requireCustomDomainAccess: boolean` require_custom_domain_access controls whether users must access via custom domain when one is configured. When true, access via app.gitpod.io is blocked. - `restrictAccountCreationToScim: boolean` restrict_account_creation_to_scim controls whether account creation is restricted to SCIM-provisioned users only. When true and SCIM is configured for the organization, only users provisioned via SCIM can create accounts. - `deleteArchivedEnvironmentsAfter: optional string` delete_archived_environments_after controls how long archived environments are kept before automatic deletion. 0 means no automatic deletion. Maximum duration is 4 weeks (2419200 seconds). - `editorVersionRestrictions: optional map[object { allowedVersions } ]` editor_version_restrictions restricts which editor versions can be used. Maps editor ID to version policy, editor_version_restrictions not set means no restrictions. If empty or not set for an editor, we will use the latest version of the editor - `allowedVersions: optional array of string` allowed_versions lists the versions that are allowed If empty, we will use the latest version of the editor Examples for JetBrains: `["2025.2", "2025.1", "2024.3"]` - `maximumEnvironmentLifetime: optional string` maximum_environment_lifetime controls for how long environments are allowed to be reused. 0 means no maximum lifetime. Maximum duration is 180 days (15552000 seconds). - `maximumEnvironmentTimeout: optional string` maximum_environment_timeout controls the maximum timeout allowed for environments in seconds. 0 means no limit (never). Minimum duration is 30 minutes (1800 seconds). value must be 0s (no limit) or at least 1800s (30 minutes): ``` this == duration('0s') || this >= duration('1800s') ``` - `securityAgentPolicy: optional SecurityAgentPolicy` security_agent_policy contains security agent configuration for the organization. When configured, security agents are automatically deployed to all environments. - `crowdstrike: optional CrowdStrikeConfig` crowdstrike contains CrowdStrike Falcon configuration - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs. Keys should NOT include the FALCONCTL_OPT_ prefix. - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID). - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor (comma-separated) - `vetoExecPolicy: optional VetoExecPolicy` veto_exec_policy contains the veto exec policy for environments. - `action: optional KernelControlsAction` action specifies what action kernel-level controls take on policy violations - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` - `enabled: optional boolean` enabled controls whether executable blocking is active - `executables: optional array of string` executables is the list of executable paths or names to block ### Security Agent Policy - `SecurityAgentPolicy object { crowdstrike }` SecurityAgentPolicy contains security agent configuration for an organization. When enabled, security agents are automatically deployed to all environments. - `crowdstrike: optional CrowdStrikeConfig` crowdstrike contains CrowdStrike Falcon configuration - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs. Keys should NOT include the FALCONCTL_OPT_ prefix. - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID). - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor (comma-separated) ### Veto Exec Policy - `VetoExecPolicy object { action, enabled, executables }` VetoExecPolicy defines the policy for blocking or auditing executable execution in environments. - `action: optional KernelControlsAction` action specifies what action kernel-level controls take on policy violations - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` - `enabled: optional boolean` enabled controls whether executable blocking is active - `executables: optional array of string` executables is the list of executable paths or names to block ### Policy Retrieve Response - `PolicyRetrieveResponse object { policies }` - `policies: OrganizationPolicies` - `agentPolicy: AgentPolicy` agent_policy contains agent-specific policy settings - `commandDenyList: array of string` command_deny_list contains a list of commands that agents are not allowed to execute - `mcpDisabled: boolean` mcp_disabled controls whether MCP (Model Context Protocol) is disabled for agents - `scmToolsDisabled: boolean` scm_tools_disabled controls whether SCM (Source Control Management) tools are disabled for agents - `conversationSharingPolicy: optional ConversationSharingPolicy` conversation_sharing_policy controls whether agent conversations can be shared - `"CONVERSATION_SHARING_POLICY_UNSPECIFIED"` - `"CONVERSATION_SHARING_POLICY_DISABLED"` - `"CONVERSATION_SHARING_POLICY_ORGANIZATION"` - `maxSubagentsPerEnvironment: optional number` max_subagents_per_environment limits the number of non-terminal sub-agents a parent can have running simultaneously in the same environment. Valid range: 0-10. Zero means use the default (5). - `scmToolsAllowedGroupId: optional string` scm_tools_allowed_group_id restricts SCM tools access to members of this group. Empty means no restriction (all users can use SCM tools if not disabled). - `allowedEditorIds: array of string` allowed_editor_ids is the list of editor IDs that are allowed to be used in the organization - `allowLocalRunners: boolean` allow_local_runners controls whether local runners are allowed to be used in the organization - `defaultEditorId: string` default_editor_id is the default editor ID to be used when a user doesn't specify one - `defaultEnvironmentImage: string` default_environment_image is the default container image when none is defined in repo - `maximumEnvironmentsPerUser: string` maximum_environments_per_user limits total environments (running or stopped) per user - `maximumRunningEnvironmentsPerUser: string` maximum_running_environments_per_user limits simultaneously running environments per user - `membersCreateProjects: boolean` members_create_projects controls whether members can create projects - `membersRequireProjects: boolean` members_require_projects controls whether environments can only be created from projects by non-admin users - `organizationId: string` organization_id is the ID of the organization - `portSharingDisabled: boolean` port_sharing_disabled controls whether user-initiated port sharing is disabled in the organization. System ports (VS Code Browser, agents) are always exempt from this policy. - `requireCustomDomainAccess: boolean` require_custom_domain_access controls whether users must access via custom domain when one is configured. When true, access via app.gitpod.io is blocked. - `restrictAccountCreationToScim: boolean` restrict_account_creation_to_scim controls whether account creation is restricted to SCIM-provisioned users only. When true and SCIM is configured for the organization, only users provisioned via SCIM can create accounts. - `deleteArchivedEnvironmentsAfter: optional string` delete_archived_environments_after controls how long archived environments are kept before automatic deletion. 0 means no automatic deletion. Maximum duration is 4 weeks (2419200 seconds). - `editorVersionRestrictions: optional map[object { allowedVersions } ]` editor_version_restrictions restricts which editor versions can be used. Maps editor ID to version policy, editor_version_restrictions not set means no restrictions. If empty or not set for an editor, we will use the latest version of the editor - `allowedVersions: optional array of string` allowed_versions lists the versions that are allowed If empty, we will use the latest version of the editor Examples for JetBrains: `["2025.2", "2025.1", "2024.3"]` - `maximumEnvironmentLifetime: optional string` maximum_environment_lifetime controls for how long environments are allowed to be reused. 0 means no maximum lifetime. Maximum duration is 180 days (15552000 seconds). - `maximumEnvironmentTimeout: optional string` maximum_environment_timeout controls the maximum timeout allowed for environments in seconds. 0 means no limit (never). Minimum duration is 30 minutes (1800 seconds). value must be 0s (no limit) or at least 1800s (30 minutes): ``` this == duration('0s') || this >= duration('1800s') ``` - `securityAgentPolicy: optional SecurityAgentPolicy` security_agent_policy contains security agent configuration for the organization. When configured, security agents are automatically deployed to all environments. - `crowdstrike: optional CrowdStrikeConfig` crowdstrike contains CrowdStrike Falcon configuration - `additionalOptions: optional map[string]` additional_options contains additional FALCONCTL_OPT_* options as key-value pairs. Keys should NOT include the FALCONCTL_OPT_ prefix. - `cidSecretId: optional string` cid_secret_id references an organization secret containing the Customer ID (CID). - `enabled: optional boolean` enabled controls whether CrowdStrike Falcon is deployed to environments - `image: optional string` image is the CrowdStrike Falcon sensor container image reference - `tags: optional string` tags are optional tags to apply to the Falcon sensor (comma-separated) - `vetoExecPolicy: optional VetoExecPolicy` veto_exec_policy contains the veto exec policy for environments. - `action: optional KernelControlsAction` action specifies what action kernel-level controls take on policy violations - `"KERNEL_CONTROLS_ACTION_UNSPECIFIED"` - `"KERNEL_CONTROLS_ACTION_BLOCK"` - `"KERNEL_CONTROLS_ACTION_AUDIT"` - `enabled: optional boolean` enabled controls whether executable blocking is active - `executables: optional array of string` executables is the list of executable paths or names to block ### Policy Update Response - `PolicyUpdateResponse = unknown` # Scim Configurations ## CreateSCIMConfiguration **post** `/gitpod.v1.OrganizationService/CreateSCIMConfiguration` Creates a new SCIM configuration for automated user provisioning. Use this method to: - Set up SCIM 2.0 provisioning from an identity provider - Generate a bearer token for SCIM API authentication - Link SCIM provisioning to an existing SSO configuration ### Examples - Create basic SCIM configuration: Creates a SCIM configuration linked to an SSO provider with default 1 year token expiration. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` - Create SCIM configuration with custom token expiration: Creates a SCIM configuration with a 90-day token expiration. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" tokenExpiresIn: "7776000s" ``` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to create the SCIM configuration for - `ssoConfigurationId: string` sso_configuration_id is the SSO configuration to link (required for user provisioning) - `name: optional string` name is a human-readable name for the SCIM configuration - `tokenExpiresIn: optional string` token_expires_in is the duration until the token expires. Defaults to 1 year. Minimum 1 day, maximum 2 years. ### Returns - `token: string` token is the bearer token for SCIM API authentication. This is only returned once during creation - store it securely. - `scimConfiguration: ScimConfiguration` scim_configuration is the created SCIM configuration - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) - `tokenExpiresAt: string` token_expires_at is when the token will expire ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateSCIMConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047", "ssoConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "token": "token", "scimConfiguration": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "tokenExpiresAt": "2019-12-27T18:11:19.117Z", "updatedAt": "2019-12-27T18:11:19.117Z", "enabled": true, "name": "name", "ssoConfigurationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" }, "tokenExpiresAt": "2019-12-27T18:11:19.117Z" } ``` ## DeleteSCIMConfiguration **post** `/gitpod.v1.OrganizationService/DeleteSCIMConfiguration` Removes a SCIM configuration from an organization. Use this method to: - Disable SCIM provisioning completely - Remove unused configurations - Clean up after migration ### Examples - Delete SCIM configuration: Removes a specific SCIM configuration. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `scimConfigurationId: string` scim_configuration_id is the ID of the SCIM configuration to delete ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/DeleteSCIMConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "scimConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json {} ``` ## ListSCIMConfigurations **post** `/gitpod.v1.OrganizationService/ListSCIMConfigurations` Lists SCIM configurations for an organization. Use this method to: - View all SCIM configurations - Monitor provisioning status - Audit SCIM settings ### Examples - List SCIM configurations: Shows all SCIM configurations for an organization. ```yaml pagination: pageSize: 20 ``` ### Query Parameters - `token: optional string` - `pageSize: optional number` ### Body Parameters - `pagination: optional object { token, pageSize }` - `token: optional string` Token for the next set of results that was returned as next_token of a PaginationResponse - `pageSize: optional number` Page size is the maximum number of results to retrieve per page. Defaults to 25. Maximum 100. ### Returns - `pagination: object { nextToken }` - `nextToken: optional string` Token passed for retrieving the next set of results. Empty if there are no more results - `scimConfigurations: optional array of ScimConfiguration` scim_configurations are the SCIM configurations for the organization - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/ListSCIMConfigurations \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{}' ``` #### Response ```json { "pagination": { "nextToken": "nextToken" }, "scimConfigurations": [ { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "tokenExpiresAt": "2019-12-27T18:11:19.117Z", "updatedAt": "2019-12-27T18:11:19.117Z", "enabled": true, "name": "name", "ssoConfigurationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" } ] } ``` ## RegenerateSCIMToken **post** `/gitpod.v1.OrganizationService/RegenerateSCIMToken` Regenerates the bearer token for a SCIM configuration. Use this method to: - Rotate SCIM credentials - Recover from token compromise - Update IdP configuration ### Examples - Regenerate token: Creates a new bearer token with the same expiration duration as the previous token. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` - Regenerate token with new expiration: Creates a new bearer token with a custom 180-day expiration. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" tokenExpiresIn: "15552000s" ``` ### Body Parameters - `scimConfigurationId: string` scim_configuration_id is the ID of the SCIM configuration to regenerate token for - `tokenExpiresIn: optional string` token_expires_in is the duration until the new token expires. If not specified, uses the same duration as the previous token. ### Returns - `token: string` token is the new bearer token for SCIM API authentication. This invalidates the previous token - store it securely. - `tokenExpiresAt: string` token_expires_at is when the new token will expire ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/RegenerateSCIMToken \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "scimConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "token": "token", "tokenExpiresAt": "2019-12-27T18:11:19.117Z" } ``` ## GetSCIMConfiguration **post** `/gitpod.v1.OrganizationService/GetSCIMConfiguration` Retrieves a specific SCIM configuration. Use this method to: - View SCIM configuration details - Check if SCIM is enabled - Verify SSO linkage ### Examples - Get SCIM configuration: Retrieves details of a specific SCIM configuration. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `scimConfigurationId: string` scim_configuration_id is the ID of the SCIM configuration to get ### Returns - `scimConfiguration: ScimConfiguration` scim_configuration is the SCIM configuration identified by the ID - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetSCIMConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "scimConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "scimConfiguration": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "tokenExpiresAt": "2019-12-27T18:11:19.117Z", "updatedAt": "2019-12-27T18:11:19.117Z", "enabled": true, "name": "name", "ssoConfigurationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" } } ``` ## UpdateSCIMConfiguration **post** `/gitpod.v1.OrganizationService/UpdateSCIMConfiguration` Updates a SCIM configuration. Use this method to: - Enable or disable SCIM provisioning - Link or unlink SSO configuration - Update configuration name ### Examples - Disable SCIM: Disables SCIM provisioning. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" enabled: false ``` - Link to SSO: Links SCIM configuration to an SSO provider. ```yaml scimConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ssoConfigurationId: "f53d2330-3795-4c5d-a1f3-453121af9c60" ``` ### Body Parameters - `scimConfigurationId: string` scim_configuration_id is the ID of the SCIM configuration to update - `enabled: optional boolean` enabled controls whether SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the SSO configuration to link ### Returns - `scimConfiguration: ScimConfiguration` scim_configuration is the updated SCIM configuration - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateSCIMConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "scimConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "scimConfiguration": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "createdAt": "2019-12-27T18:11:19.117Z", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "tokenExpiresAt": "2019-12-27T18:11:19.117Z", "updatedAt": "2019-12-27T18:11:19.117Z", "enabled": true, "name": "name", "ssoConfigurationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e" } } ``` ## Domain Types ### Scim Configuration - `ScimConfiguration object { id, createdAt, organizationId, 5 more }` SCIMConfiguration represents a SCIM 2.0 provisioning configuration - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) ### Scim Configuration Create Response - `ScimConfigurationCreateResponse object { token, scimConfiguration, tokenExpiresAt }` - `token: string` token is the bearer token for SCIM API authentication. This is only returned once during creation - store it securely. - `scimConfiguration: ScimConfiguration` scim_configuration is the created SCIM configuration - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) - `tokenExpiresAt: string` token_expires_at is when the token will expire ### Scim Configuration Delete Response - `ScimConfigurationDeleteResponse = unknown` ### Scim Configuration Regenerate Token Response - `ScimConfigurationRegenerateTokenResponse object { token, tokenExpiresAt }` - `token: string` token is the new bearer token for SCIM API authentication. This invalidates the previous token - store it securely. - `tokenExpiresAt: string` token_expires_at is when the new token will expire ### Scim Configuration Retrieve Response - `ScimConfigurationRetrieveResponse object { scimConfiguration }` - `scimConfiguration: ScimConfiguration` scim_configuration is the SCIM configuration identified by the ID - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) ### Scim Configuration Update Response - `ScimConfigurationUpdateResponse object { scimConfiguration }` - `scimConfiguration: ScimConfiguration` scim_configuration is the updated SCIM configuration - `id: string` id is the unique identifier of the SCIM configuration - `createdAt: string` created_at is when the SCIM configuration was created - `organizationId: string` organization_id is the ID of the organization this SCIM configuration belongs to - `tokenExpiresAt: string` token_expires_at is when the current SCIM token expires - `updatedAt: string` updated_at is when the SCIM configuration was last updated - `enabled: optional boolean` enabled indicates if SCIM provisioning is active - `name: optional string` name is a human-readable name for the SCIM configuration - `ssoConfigurationId: optional string` sso_configuration_id is the linked SSO configuration (optional) # SSO Configurations ## CreateSSOConfiguration **post** `/gitpod.v1.OrganizationService/CreateSSOConfiguration` Creates or updates SSO configuration for organizational authentication. Use this method to: - Configure OIDC-based SSO providers - Set up built-in providers (Google, GitHub, etc.) - Define custom identity providers - Manage authentication policies ### Examples - Configure built-in Google SSO: Sets up SSO using Google Workspace. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" clientId: "012345678-abcdefghijklmnopqrstuvwxyz.apps.googleusercontent.com" clientSecret: "GOCSPX-abcdefghijklmnopqrstuvwxyz123456" issuerUrl: "https://accounts.google.com" emailDomain: "acme-corp.com" ``` - Configure custom OIDC provider: Sets up SSO with a custom identity provider. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" clientId: "acme-corp-gitpod" clientSecret: "secret-token-value" issuerUrl: "https://sso.acme-corp.com" emailDomain: "acme-corp.com" ``` ### Body Parameters - `clientId: string` client_id is the client ID of the OIDC application set on the IdP - `clientSecret: string` client_secret is the client secret of the OIDC application set on the IdP - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes to request from the identity provider during sign-in. These are appended to the default scopes (openid, email, profile). - `claimsExpression: optional string` claims_expression is an optional CEL expression evaluated against OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `displayName: optional string` - `emailDomain: optional string` email_domain is the domain that is allowed to sign in to the organization - `emailDomains: optional array of string` ### Returns - `ssoConfiguration: SSOConfiguration` sso_configuration is the created SSO configuration - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/CreateSSOConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "clientId": "012345678-abcdefghijklmnopqrstuvwxyz.apps.googleusercontent.com", "clientSecret": "GOCSPX-abcdefghijklmnopqrstuvwxyz123456", "issuerUrl": "https://accounts.google.com", "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "ssoConfiguration": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "issuerUrl": "issuerUrl", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "providerType": "PROVIDER_TYPE_UNSPECIFIED", "state": "SSO_CONFIGURATION_STATE_UNSPECIFIED", "additionalScopes": [ "string" ], "claims": { "foo": "string" }, "claimsExpression": "claimsExpression", "clientId": "clientId", "displayName": "displayName", "emailDomain": "emailDomain", "emailDomains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } } ``` ## DeleteSSOConfiguration **post** `/gitpod.v1.OrganizationService/DeleteSSOConfiguration` Removes an SSO configuration from an organization. Use this method to: - Disable SSO authentication - Remove outdated providers - Clean up unused configurations ### Examples - Delete SSO configuration: Removes a specific SSO configuration. ```yaml ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `ssoConfigurationId: string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/DeleteSSOConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "ssoConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json {} ``` ## ListSSOConfigurations **post** `/gitpod.v1.OrganizationService/ListSSOConfigurations` Lists and filters SSO configurations for an organization. Use this method to: - View all SSO providers - Monitor authentication status - Audit security settings - Manage provider configurations ### Examples - List active configurations: Shows all active SSO providers. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 20 ``` - List by provider type: Shows custom SSO configurations. ```yaml organizationId: "b0e12f6c-4c67-429d-a4a6-d9838b5da047" pagination: pageSize: 20 token: "next-page-token-from-previous-response" ``` ### Query Parameters - `token: optional string` - `pageSize: optional number` ### Body Parameters - `organizationId: string` organization_id is the ID of the organization to list SSO configurations for. - `pagination: optional object { token, pageSize }` - `token: optional string` Token for the next set of results that was returned as next_token of a PaginationResponse - `pageSize: optional number` Page size is the maximum number of results to retrieve per page. Defaults to 25. Maximum 100. ### Returns - `pagination: object { nextToken }` - `nextToken: optional string` Token passed for retrieving the next set of results. Empty if there are no more results - `ssoConfigurations: optional array of SSOConfiguration` sso_configurations are the SSO configurations for the organization - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/ListSSOConfigurations \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "organizationId": "b0e12f6c-4c67-429d-a4a6-d9838b5da047" }' ``` #### Response ```json { "pagination": { "nextToken": "nextToken" }, "ssoConfigurations": [ { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "issuerUrl": "issuerUrl", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "providerType": "PROVIDER_TYPE_UNSPECIFIED", "state": "SSO_CONFIGURATION_STATE_UNSPECIFIED", "additionalScopes": [ "string" ], "claims": { "foo": "string" }, "claimsExpression": "claimsExpression", "clientId": "clientId", "displayName": "displayName", "emailDomain": "emailDomain", "emailDomains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } ] } ``` ## GetSSOConfiguration **post** `/gitpod.v1.OrganizationService/GetSSOConfiguration` Retrieves a specific SSO configuration. Use this method to: - View SSO provider details - Check configuration status - Verify SSO settings ### Examples - Get SSO configuration: Retrieves details of a specific SSO configuration. ```yaml ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" ``` ### Body Parameters - `ssoConfigurationId: string` sso_configuration_id is the ID of the SSO configuration to get ### Returns - `ssoConfiguration: SSOConfiguration` sso_configuration is the SSO configuration identified by the ID - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/GetSSOConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "ssoConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json { "ssoConfiguration": { "id": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "issuerUrl": "issuerUrl", "organizationId": "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", "providerType": "PROVIDER_TYPE_UNSPECIFIED", "state": "SSO_CONFIGURATION_STATE_UNSPECIFIED", "additionalScopes": [ "string" ], "claims": { "foo": "string" }, "claimsExpression": "claimsExpression", "clientId": "clientId", "displayName": "displayName", "emailDomain": "emailDomain", "emailDomains": [ "sfN2.l.iJR-BU.u9JV9.a.m.o2D-4b-Jd.0Z-kX.L.n.S.f.UKbxB" ] } } ``` ## UpdateSSOConfiguration **post** `/gitpod.v1.OrganizationService/UpdateSSOConfiguration` Updates SSO provider settings and authentication rules. Use this method to: - Rotate client credentials - Update provider endpoints - Modify claim mappings - Change authentication policies - Toggle SSO enforcement ### Examples - Update credentials: Rotates client ID and secret. ```yaml ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" clientId: "new-client-id" clientSecret: "new-client-secret" ``` - Update provider status: Activates or deactivates SSO provider. ```yaml ssoConfigurationId: "d2c94c27-3b76-4a42-b88c-95a85e392c68" state: SSO_CONFIGURATION_STATE_ACTIVE ``` ### Body Parameters - `ssoConfigurationId: string` sso_configuration_id is the ID of the SSO configuration to update - `additionalScopes: optional AdditionalScopesUpdate` additional_scopes replaces the configured OIDC scopes when present. When absent (nil), scopes are left unchanged. When present with an empty scopes list, all additional scopes are cleared. - `scopes: optional array of string` - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL expression evaluated against OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. When present with an empty string, the expression is cleared. - `clientId: optional string` client_id is the client ID of the SSO provider - `clientSecret: optional string` client_secret is the client secret of the SSO provider - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` - `issuerUrl: optional string` issuer_url is the URL of the IdP issuer - `state: optional SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` ### Example ```http curl https://app.gitpod.io/api/gitpod.v1.OrganizationService/UpdateSSOConfiguration \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $GITPOD_API_KEY" \ -d '{ "ssoConfigurationId": "d2c94c27-3b76-4a42-b88c-95a85e392c68" }' ``` #### Response ```json {} ``` ## Domain Types ### Additional Scopes Update - `AdditionalScopesUpdate object { scopes }` AdditionalScopesUpdate wraps a list of OIDC scopes so that the update request can distinguish "not changing scopes" (field absent) from "clearing all scopes" (field present, empty list). - `scopes: optional array of string` ### Provider Type - `ProviderType = "PROVIDER_TYPE_UNSPECIFIED" or "PROVIDER_TYPE_BUILTIN" or "PROVIDER_TYPE_CUSTOM"` - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` ### SSO Configuration - `SSOConfiguration object { id, issuerUrl, organizationId, 9 more }` - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### SSO Configuration State - `SSOConfigurationState = "SSO_CONFIGURATION_STATE_UNSPECIFIED" or "SSO_CONFIGURATION_STATE_INACTIVE" or "SSO_CONFIGURATION_STATE_ACTIVE"` - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` ### SSO Configuration Create Response - `SSOConfigurationCreateResponse object { ssoConfiguration }` - `ssoConfiguration: SSOConfiguration` sso_configuration is the created SSO configuration - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### SSO Configuration Delete Response - `SSOConfigurationDeleteResponse = unknown` ### SSO Configuration Retrieve Response - `SSOConfigurationRetrieveResponse object { ssoConfiguration }` - `ssoConfiguration: SSOConfiguration` sso_configuration is the SSO configuration identified by the ID - `id: string` id is the unique identifier of the SSO configuration - `issuerUrl: string` issuer_url is the URL of the IdP issuer - `organizationId: string` - `providerType: ProviderType` provider_type defines the type of the SSO configuration - `"PROVIDER_TYPE_UNSPECIFIED"` - `"PROVIDER_TYPE_BUILTIN"` - `"PROVIDER_TYPE_CUSTOM"` - `state: SSOConfigurationState` state is the state of the SSO configuration - `"SSO_CONFIGURATION_STATE_UNSPECIFIED"` - `"SSO_CONFIGURATION_STATE_INACTIVE"` - `"SSO_CONFIGURATION_STATE_ACTIVE"` - `additionalScopes: optional array of string` additional_scopes are extra OIDC scopes requested from the identity provider during sign-in. - `claims: optional map[string]` claims are key/value pairs that defines a mapping of claims issued by the IdP. - `claimsExpression: optional string` claims_expression is a CEL (Common Expression Language) expression evaluated against the OIDC token claims during login. When set, the expression must evaluate to true for the login to succeed. The expression has access to a `claims` variable containing all token claims as a map. Example: `claims.email_verified && claims.email.endsWith("@example.com")` - `clientId: optional string` client_id is the client ID of the OIDC application set on the IdP - `displayName: optional string` - `emailDomain: optional string` - `emailDomains: optional array of string` ### SSO Configuration Update Response - `SSOConfigurationUpdateResponse = unknown`