# Events

Events in Prism / Objects — Micro TypeScript reference.

Reference for TypeScript SDK **0.14.0**.

[Release source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/api.md) · [Setup and client configuration](/docs/reference/typescript)

## create

`POST /v2/prism/{teamId}/event`

````text
client.prism.objects.events.create({ ...params }) -> EventCreateResponse
````

Creates a record. For `document`, writing `content` (or HTML) stores the
property and reads back, but the in-app editor is CRDT-backed and will render a
blank page until that document has been opened and saved in the app. Treat
API-created docs as data records, not as collaboratively edited pages, unless
you only need the stored property values.

```ts
const event = await client.prism.objects.events.create({
  default: {
    full_name: 'Sarah Chen',
    email: 'sarah@example.com',
    title: 'Partner',
    organization: 'Acme Ventures',
  },
});
```

## update

`PATCH /v2/prism/{teamId}/event/{eventId}`

````text
client.prism.objects.events.update(eventID, { ...params }) -> EventUpdateResponse
````

Patch object

```ts
const event = await client.prism.objects.events.update(
  '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
  { default: { title: 'General Partner' } },
);
```

## list

`GET /v2/prism/{teamId}/event`

````text
client.prism.objects.events.list({ ...params }) -> EventListResponse
````

Convenience list endpoint. Equivalent to
`POST /v2/prism/{teamId}/{objectType}/query` with an empty body, plus
query-string sugar for the common cases. Any unrecognized query parameter is
interpreted as an equality filter on a property of that name; pass arrays for
`in`. Values are received as strings, so non-string property filters via this
endpoint may not work — use the `query` endpoint for typed comparisons or
anything beyond simple equality.

```ts
const events = await client.prism.objects.events.list();
```

## delete

`DELETE /v2/prism/{teamId}/event/{eventId}`

````text
client.prism.objects.events.delete(eventID, { ...params }) -> void
````

Delete object

```ts
await client.prism.objects.events.delete(
  '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
);
```

## count

`GET /v2/prism/{teamId}/event/count`

````text
client.prism.objects.events.count({ ...params }) -> EventCountResponse
````

Returns the total number of records of this object type that the caller can see.
Avoids the page-overshoot anti-pattern — clients no longer need to keep paging
until `has_more` flips false to discover the total. Currently does not apply
query filters; for a filtered total, pass `include_total: true` in a POST
`/query` body. Unfiltered counts on high-cardinality types (especially
`engagement`) scan the full access-scoped set and can take tens of seconds or
time out; prefer a filtered `include_total` query or accept that this endpoint
is expensive there.

```ts
const response = await client.prism.objects.events.count();
```

## duplicate

`POST /v2/prism/{teamId}/event/{eventId}/duplicate`

````text
client.prism.objects.events.duplicate(eventID, { ...params }) -> EventDuplicateResponse
````

Duplicate object

```ts
const response =
  await client.prism.objects.events.duplicate(
    '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
  );
```

## find

`GET /v2/prism/{teamId}/event/by/{slug}/{value}`

````text
client.prism.objects.events.find(value, { ...params }) -> EventFindResponse
````

Returns the single record whose property `{slug}` equals `{value}`. 404 if
nothing matches; 409 if more than one record matches.

```ts
const response = await client.prism.objects.events.find(
  'value',
  { slug: 'slug' },
);
```

## get

`GET /v2/prism/{teamId}/event/{eventId}`

````text
client.prism.objects.events.get(eventID, { ...params }) -> EventGetResponse
````

Get object

```ts
const event = await client.prism.objects.events.get(
  '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
);
```

## query

`POST /v2/prism/{teamId}/event/query`

````text
client.prism.objects.events.query({ ...params }) -> EventQueryResponse
````

Query

```ts
const response = await client.prism.objects.events.query({
  query: {
    select: ['full_name', 'email', 'title', 'organization'],
    filter: [{ full_name: { '=': 'Sarah Chen' } }],
    limit: 10,
  },
  include_total: true,
});
```

## restore

`POST /v2/prism/{teamId}/event/{eventId}/restore`

````text
client.prism.objects.events.restore(eventID, { ...params }) -> EventRestoreResponse
````

Restore object

```ts
const response = await client.prism.objects.events.restore(
  '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
);
```

## upsert

`PUT /v2/prism/{teamId}/event/by/{slug}/{value}`

````text
client.prism.objects.events.upsert(value, { ...params }) -> EventUpsertResponse
````

Idempotent create-or-update keyed on `{slug}={value}`. If exactly one record
matches, it is patched and 200 is returned. If none match, a new record is
created (with the lookup property set if absent) and 201 is returned. If
multiple records match, 409 is returned and you should patch by id instead.

```ts
const response = await client.prism.objects.events.upsert(
  'value',
  { slug: 'slug' },
);
```

## Parameter and response types

These declarations show the request parameters and response shapes used by the methods above.

### Event

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface Event {
  /**
   * Properties keyed by property slug. Values can be strings, numbers, booleans,
   * arrays, or null. For select/multiselect properties, values may be option slugs
   * or option UUIDs on write; option slugs are returned on read.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventCreateResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventCreateResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventUpdateResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventUpdateResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventListResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventListResponse {
  data: Array<EventListResponse.Data>;

  /**
   * Accurate end-of-data signal — false on the last page, never forces clients to
   * overshoot.
   */
  has_more: boolean;

  next_cursor?: string | null;

  /**
   * Populated only when `?include_total=true` was passed.
   */
  total?: number | null;
}
````


### EventListResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export namespace EventListResponse {
  /**
   * Row returned by the query endpoint. `id` is always present at the top level.
   * Selected property values are returned under `properties`, keyed by property
   * slug. Reference-typed values are returned as nested `{ id, properties }`
   * objects.
   */
  export interface Data {
    id: string;

    is_user_object?: boolean;

    /**
     * Selected property values keyed by property slug. For select/multiselect
     * properties, option slugs are returned. For reference properties, values are
     * nested `{ id, properties }` objects.
     */
    properties?: { [key: string]: unknown };

    source?: Array<string> | null;
  }
}
````


### EventCountResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventCountResponse {
  /**
   * Number of records matching the access scope.
   */
  total: number;
}
````


### EventDuplicateResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventDuplicateResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventFindResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventFindResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventGetResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventGetResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventQueryResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventQueryResponse {
  data: Array<EventQueryResponse.Data>;

  /**
   * Accurate end-of-data signal. False when this page contains the last record; true
   * only when at least one more record exists. (Implementation note: the server
   * fetches one extra row internally to determine this — clients never need to
   * overshoot to discover the end.)
   */
  has_more: boolean;

  /**
   * Opaque cursor pointing at the next page. Pass it back unchanged. Do not parse
   * it. The current encoding is offset-based (page + limit), so it has the same
   * concurrent-write drift the deprecated `page` parameter has; treat it as a black
   * box so a future keyset cursor is a drop-in. Null when `has_more` is false.
   */
  next_cursor?: string | null;

  /**
   * Only populated when the request set `include_total: true`. Total number of
   * records matching the query, ignoring pagination. Opt-in because it costs an
   * additional pass over the result set.
   */
  total?: number | null;
}
````


### EventQueryResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export namespace EventQueryResponse {
  /**
   * Row returned by the query endpoint. `id` is always present at the top level.
   * Selected property values are returned under `properties`, keyed by property
   * slug. Reference-typed values are returned as nested `{ id, properties }`
   * objects.
   */
  export interface Data {
    id: string;

    is_user_object?: boolean;

    /**
     * Selected property values keyed by property slug. For select/multiselect
     * properties, option slugs are returned. For reference properties, values are
     * nested `{ id, properties }` objects.
     */
    properties?: { [key: string]: unknown };

    source?: Array<string> | null;
  }
}
````


### EventRestoreResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventRestoreResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventUpsertResponse

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
/**
 * Object returned by reads (get/create/patch/restore). id is always present.
 */
export interface EventUpsertResponse {
  id: string;

  /**
   * Properties keyed by property slug.
   */
  default?: { [key: string]: unknown };

  list?: unknown;
}
````


### EventCreateParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventCreateParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Body param: Properties keyed by property slug. Values can be strings, numbers,
   * booleans, arrays, or null. For select/multiselect properties, values may be
   * option slugs or option UUIDs on write; option slugs are returned on read.
   */
  default?: { [key: string]: unknown };

  /**
   * Body param
   */
  list?: unknown;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;
}
````


### EventUpdateParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventUpdateParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Body param: Properties keyed by property slug. Values can be strings, numbers,
   * booleans, arrays, or null. For select/multiselect properties, values may be
   * option slugs or option UUIDs on write; option slugs are returned on read.
   */
  default?: { [key: string]: unknown };

  /**
   * Body param
   */
  list?: unknown;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;

  /**
   * Header param: Optimistic concurrency. Pass back the `etag` header from a
   * previous GET of this record; the write only proceeds if the record hasn't
   * changed since. Mismatch → 412 `precondition_failed`. Use `*` to require the
   * record exists (any ETag accepted).
   */
  'If-Match'?: string;
}
````


### EventListParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventListParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Query param: Opaque cursor from a previous response's `next_cursor`. Pass it
   * back unchanged to fetch the next page.
   */
  cursor?: string;

  /**
   * Query param: Include soft-deleted records. Pass the literal string `true`.
   */
  deleted?: boolean;

  /**
   * Query param: When set to `true`, the response includes a `total` field with the
   * unpaginated row count. Costs an extra pass; prefer `GET .../count` for the
   * unfiltered total.
   */
  include_total?: boolean;

  /**
   * Query param: Maximum number of rows to return. Capped server-side at 50.
   */
  limit?: number;

  /**
   * Query param: Scope properties to a specific list/app.
   */
  list_id?: string;

  /**
   * Query param: Comma-separated property slugs to return. Use dot notation for
   * relationships. `id` is always returned at the top level. Defaults to all
   * properties.
   */
  select?: string;

  /**
   * Query param: Comma-separated list of slugs. Prefix with `-` for descending.
   * Example: `sort=-updated_at,name`.
   */
  sort?: string;
}
````


### EventDeleteParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventDeleteParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Header param: Optimistic concurrency. Pass back the `etag` header from a
   * previous GET of this record; the write only proceeds if the record hasn't
   * changed since. Mismatch → 412 `precondition_failed`. Use `*` to require the
   * record exists (any ETag accepted).
   */
  'If-Match'?: string;
}
````


### EventCountParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventCountParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Query param: Scope the count to a specific list/app.
   */
  list_id?: string;
}
````


### EventDuplicateParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventDuplicateParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;
}
````


### EventFindParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventFindParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Path param: Property slug to match (e.g. `email`).
   */
  slug: string;

  /**
   * Query param: Scope the lookup to a specific list/app.
   */
  list_id?: string;
}
````


### EventGetParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventGetParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Query param: Comma-separated property slugs to return. Use dot notation for
   * relationships. `id` is always returned at the top level. Defaults to all
   * properties.
   */
  select?: string;
}
````


### EventQueryParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventQueryParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Body param
   */
  query: EventQueryParams.Query;

  /**
   * Body param
   */
  id?: string | Array<string>;

  /**
   * Body param
   */
  boxes?: Array<string>;

  /**
   * Body param: Alternative location for the opaque cursor (a sibling of `query`).
   * Use whichever feels more natural; if both are present, `query.cursor` wins.
   */
  cursor?: string;

  /**
   * Body param
   */
  deleted?: boolean;

  /**
   * Body param: When true, the response includes a `total` field with the
   * unpaginated row count. Costs an additional pass over the result set — for
   * unfiltered totals prefer `GET /v2/prism/{teamId}/{objectType}/count` instead.
   */
  include_total?: boolean;

  /**
   * Body param
   */
  sources?: Array<string>;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;
}
````


### EventQueryParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export namespace EventQueryParams {
  export interface Query {
    /**
     * Property slugs to select. Use dot notation for relationships (e.g.
     * attendee.contact.first_name). `id` is always returned at the top level of each
     * row and does not need to be selected.
     */
    select: Array<string>;

    /**
     * Logical operator for combining filters
     */
    combinator?: 'AND' | 'OR';

    /**
     * Opaque cursor from a previous response's `next_cursor`. Pass it back unchanged
     * to fetch the next page. When set, `page` and `limit` are derived from the cursor
     * and any explicit values are ignored.
     */
    cursor?: string;

    /**
     * Filters as [{ slug: { operator: value } }]. For select/multiselect properties,
     * values may be option slugs or option UUIDs.
     */
    filter?: Array<{
      [key: string]:
        | Query.PrismQueryFilterEq
        | Query.PrismQueryFilterNe
        | Query.PrismQueryFilterLt
        | Query.PrismQueryFilterGt
        | Query.PrismQueryFilterLte
        | Query.PrismQueryFilterGte
        | Query.Contains
        | Query.BeginsWith
        | Query.EndsWith
        | Query.NotContains
        | Query.Exists
        | Query.NotExists
        | Query.IsNull
        | Query.IsNotNull
        | Query.Between
        | Query.In
        | Query.NotIn;
    }>;

    /**
     * Maximum number of rows to return. Capped server-side at 50; requests above the
     * cap are rejected.
     */
    limit?: number;

    list_id?: string;

    /**
     * @deprecated Page number (1-based). Prefer `cursor`. Page-number pagination
     * drifts under concurrent writes; use it only for one-shot exports.
     */
    page?: number;

    /**
     * Sort order as [{ slug: direction }]. Array order determines sort priority
     */
    sort?: Array<{ [key: string]: 'asc' | 'desc' }>;
  }

  export namespace Query {
    export interface PrismQueryFilterEq {
      '=': string | boolean;
    }

    export interface PrismQueryFilterNe {
      '!=': string | boolean;
    }

    export interface PrismQueryFilterLt {
      '<': string;
    }

    export interface PrismQueryFilterGt {
      '>': string;
    }

    export interface PrismQueryFilterLte {
      '<=': string;
    }

    export interface PrismQueryFilterGte {
      '>=': string;
    }

    export interface Contains {
      contains: string | boolean | Array<string>;
    }

    export interface BeginsWith {
      begins_with: string;
    }

    export interface EndsWith {
      ends_with: string;
    }

    export interface NotContains {
      not_contains: string;
    }

    export interface Exists {
      exists: boolean;
    }

    export interface NotExists {
      not_exists: boolean;
    }

    export interface IsNull {
      is_null: string | boolean | Array<string>;
    }

    export interface IsNotNull {
      is_not_null: string | boolean | Array<string>;
    }

    export interface Between {
      between: string | boolean | Array<string>;
    }

    export interface In {
      in: Array<string>;
    }

    export interface NotIn {
      not_in: Array<string>;
    }
  }
}
````


### EventRestoreParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventRestoreParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;
}
````


### EventUpsertParams

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export interface EventUpsertParams {
  /**
   * Path param
   */
  teamId?: string;

  /**
   * Path param
   */
  slug: string;

  /**
   * Query param: Scope the upsert to a specific list/app. Required to match or write
   * list-scoped properties, including `app_stage`.
   */
  list_id?: string;

  /**
   * Body param: Properties keyed by property slug. Values can be strings, numbers,
   * booleans, arrays, or null. For select/multiselect properties, values may be
   * option slugs or option UUIDs on write; option slugs are returned on read.
   */
  default?: { [key: string]: unknown };

  /**
   * Body param
   */
  list?: unknown;

  /**
   * Header param: A unique key (UUID or any opaque string up to 255 chars) for an
   * authenticated POST, PUT, or PATCH request. The server retains the initial claim
   * for 24 hours and replays a completed non-5xx response only when the method,
   * path, and request body all match. Reusing a non-expired key with a different
   * method, path, or body returns 409 `idempotency_key_mismatch`; reusing it after
   * expiry returns 409 `idempotency_key_stale`, so use a new key. Replays include
   * the `idempotent-replay: true` response header.
   */
  'Idempotency-Key'?: string;
}
````


### Events

[Source](https://github.com/micro-so/micro-sdk-ts/blob/v0.14.0/src/resources/prism/objects/events/events.ts)

````text
export declare namespace Events {
  export {
    type Event as Event,
    type EventCreateResponse as EventCreateResponse,
    type EventUpdateResponse as EventUpdateResponse,
    type EventListResponse as EventListResponse,
    type EventCountResponse as EventCountResponse,
    type EventDuplicateResponse as EventDuplicateResponse,
    type EventFindResponse as EventFindResponse,
    type EventGetResponse as EventGetResponse,
    type EventQueryResponse as EventQueryResponse,
    type EventRestoreResponse as EventRestoreResponse,
    type EventUpsertResponse as EventUpsertResponse,
    type EventCreateParams as EventCreateParams,
    type EventUpdateParams as EventUpdateParams,
    type EventListParams as EventListParams,
    type EventDeleteParams as EventDeleteParams,
    type EventCountParams as EventCountParams,
    type EventDuplicateParams as EventDuplicateParams,
    type EventFindParams as EventFindParams,
    type EventGetParams as EventGetParams,
    type EventQueryParams as EventQueryParams,
    type EventRestoreParams as EventRestoreParams,
    type EventUpsertParams as EventUpsertParams,
  };

  export {
    Grant as Grant,
    type GrantUpdateResponse as GrantUpdateResponse,
    type GrantGetResponse as GrantGetResponse,
    type GrantUpdateParams as GrantUpdateParams,
    type GrantGetParams as GrantGetParams,
  };
}
````