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

# Unarchive



## OpenAPI

````yaml post /okapicrm.v1.OkapiCRMService/UnarchiveRecord
openapi: 3.1.0
info:
  description: ''
  title: Okapi
  version: v1.0.0-alpha
servers: []
security: []
tags:
  - description: ''
    name: okapicrm.v1.OkapiCRMService
paths:
  /okapicrm.v1.OkapiCRMService/UnarchiveRecord:
    post:
      tags:
        - okapicrm.v1.OkapiCRMService
      requestBody:
        $ref: >-
          #/components/requestBodies/okapicrm.v1.OkapiCRMService.UnarchiveRecord.okapicrm.v1.UnarchiveRecordRequest
      responses:
        '200':
          $ref: >-
            #/components/responses/okapicrm.v1.OkapiCRMService.UnarchiveRecord.okapicrm.v1.Record
        default:
          $ref: '#/components/responses/connect.error'
components:
  requestBodies:
    okapicrm.v1.OkapiCRMService.UnarchiveRecord.okapicrm.v1.UnarchiveRecordRequest:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/okapicrm.v1.UnarchiveRecordRequest'
        application/proto:
          schema:
            $ref: '#/components/schemas/okapicrm.v1.UnarchiveRecordRequest'
      required: true
  responses:
    okapicrm.v1.OkapiCRMService.UnarchiveRecord.okapicrm.v1.Record:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/okapicrm.v1.Record'
        application/proto:
          schema:
            $ref: '#/components/schemas/okapicrm.v1.Record'
      description: ''
    connect.error:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/connect.error'
        application/proto:
          schema:
            $ref: '#/components/schemas/connect.error'
      description: ''
  schemas:
    okapicrm.v1.UnarchiveRecordRequest:
      additionalProperties: false
      description: ''
      properties:
        id:
          additionalProperties: false
          description: ''
          title: id
          type: string
      title: UnarchiveRecordRequest
      type: object
    okapicrm.v1.Record:
      additionalProperties: false
      description: ''
      properties:
        archived:
          additionalProperties: false
          description: ''
          title: archived
          type: boolean
        createTime:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          additionalProperties: false
          description: ''
          title: create_time
          type: object
        createdBy:
          $ref: '#/components/schemas/okapicrm.v1.Actor'
          additionalProperties: false
          description: ''
          title: created_by
          type: object
        deleted:
          additionalProperties: false
          description: ''
          title: deleted
          type: boolean
        fields:
          additionalProperties: false
          description: ''
          title: fields
          type: object
        formulaErrors:
          additionalProperties: false
          description: ''
          title: formula_errors
          type: object
        id:
          additionalProperties: false
          description: ''
          title: id
          type: string
        objectApiName:
          additionalProperties: false
          description: ''
          title: object_api_name
          type: string
        objectId:
          additionalProperties: false
          description: ''
          title: object_id
          type: string
      title: Record
      type: object
    connect.error:
      additionalProperties: false
      description: >-
        Error type returned by Connect:
        https://connectrpc.com/docs/go/errors/#http-representation
      properties:
        code:
          description: >-
            The status code, which should be an enum value of
            [google.rpc.Code][google.rpc.Code].
          enum:
            - CodeCanceled
            - CodeUnknown
            - CodeInvalidArgument
            - CodeDeadlineExceeded
            - CodeNotFound
            - CodeAlreadyExists
            - CodePermissionDenied
            - CodeResourceExhausted
            - CodeFailedPrecondition
            - CodeAborted
            - CodeOutOfRange
            - CodeInternal
            - CodeUnavailable
            - CodeDataLoss
            - CodeUnauthenticated
          examples:
            - CodeNotFound
          type: string
        detail:
          items:
            $ref: '#/components/schemas/google.protobuf.Any'
          type: array
        message:
          description: >-
            A developer-facing error message, which should be in English. Any
            user-facing error message should be localized and sent in the
            [google.rpc.Status.details][google.rpc.Status.details] field, or
            localized by the client.
          type: string
      title: Connect Error
      type: object
    google.protobuf.Timestamp:
      additionalProperties: false
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

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

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

         # Examples

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

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

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

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

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

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

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

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

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

             long millis = System.currentTimeMillis();

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

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

             Instant now = Instant.now();

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

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

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

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

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
      format: date-time
      type: string
    okapicrm.v1.Actor:
      additionalProperties: false
      description: ''
      properties:
        apiKeyId:
          additionalProperties: false
          description: ''
          title: api_key_id
          type: string
        builtinIntegration:
          $ref: '#/components/schemas/okapicrm.v1.BuiltinIntegration'
          additionalProperties: false
          description: ''
          title: builtin_integration
        userId:
          additionalProperties: false
          description: ''
          title: user_id
          type: string
      title: Actor
      type: object
    google.protobuf.Any:
      additionalProperties: true
      description: >-
        Contains an arbitrary serialized message along with a @type that
        describes the type of the serialized message.
      id: google.protobuf.Any
      properties:
        '@type':
          description: The type of the serialized message.
          type: string
      type: object
    okapicrm.v1.BuiltinIntegration:
      description: ''
      enum:
        - - BUILTIN_INTEGRATION_UNSPECIFIED
          - BUILTIN_INTEGRATION_GMAIL_V1
          - BUILTIN_INTEGRATION_OUTLOOK_V1
          - BUILTIN_INTEGRATION_LINKEDIN_V1
      title: BuiltinIntegration
      type: string

````