@aws-sdk/client-opensearchmemory 0.0.0-stage → 3.1170.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (157) hide show
  1. package/LICENSE +201 -0
  2. package/README.md +320 -2
  3. package/dist-cjs/index.js +1550 -0
  4. package/dist-es/OpenSearchMemory.js +65 -0
  5. package/dist-es/OpenSearchMemoryClient.js +47 -0
  6. package/dist-es/auth/httpAuthExtensionConfiguration.js +38 -0
  7. package/dist-es/auth/httpAuthSchemeProvider.js +40 -0
  8. package/dist-es/commandBuilder.js +9 -0
  9. package/dist-es/commands/BatchGetEventCommand.js +4 -0
  10. package/dist-es/commands/CreateEventCommand.js +4 -0
  11. package/dist-es/commands/CreateMemoryCommand.js +4 -0
  12. package/dist-es/commands/CreateSpaceCommand.js +4 -0
  13. package/dist-es/commands/DeleteEventCommand.js +4 -0
  14. package/dist-es/commands/DeleteMemoryCommand.js +4 -0
  15. package/dist-es/commands/DeleteSpaceCommand.js +4 -0
  16. package/dist-es/commands/GetEventCommand.js +4 -0
  17. package/dist-es/commands/GetMemoryCommand.js +4 -0
  18. package/dist-es/commands/GetSpaceCommand.js +4 -0
  19. package/dist-es/commands/ListEventsCommand.js +4 -0
  20. package/dist-es/commands/ListMemoriesCommand.js +4 -0
  21. package/dist-es/commands/ListSpacesCommand.js +4 -0
  22. package/dist-es/commands/ListTagsForResourceCommand.js +4 -0
  23. package/dist-es/commands/SearchEventsCommand.js +4 -0
  24. package/dist-es/commands/SearchMemoriesCommand.js +4 -0
  25. package/dist-es/commands/TagResourceCommand.js +4 -0
  26. package/dist-es/commands/UntagResourceCommand.js +4 -0
  27. package/dist-es/commands/UpdateMemoryCommand.js +4 -0
  28. package/dist-es/commands/UpdateSpaceCommand.js +4 -0
  29. package/dist-es/commands/index.js +20 -0
  30. package/dist-es/endpoint/EndpointParameters.js +11 -0
  31. package/dist-es/endpoint/bdd.js +33 -0
  32. package/dist-es/endpoint/endpointResolver.js +14 -0
  33. package/dist-es/extensionConfiguration.js +1 -0
  34. package/dist-es/index.js +11 -0
  35. package/dist-es/models/OpenSearchMemoryServiceException.js +9 -0
  36. package/dist-es/models/enums.js +61 -0
  37. package/dist-es/models/errors.js +114 -0
  38. package/dist-es/models/models_0.js +1 -0
  39. package/dist-es/pagination/Interfaces.js +1 -0
  40. package/dist-es/pagination/ListEventsPaginator.js +4 -0
  41. package/dist-es/pagination/ListMemoriesPaginator.js +4 -0
  42. package/dist-es/pagination/ListSpacesPaginator.js +4 -0
  43. package/dist-es/pagination/SearchEventsPaginator.js +4 -0
  44. package/dist-es/pagination/SearchMemoriesPaginator.js +4 -0
  45. package/dist-es/pagination/index.js +6 -0
  46. package/dist-es/runtimeConfig.browser.js +29 -0
  47. package/dist-es/runtimeConfig.js +44 -0
  48. package/dist-es/runtimeConfig.native.js +9 -0
  49. package/dist-es/runtimeConfig.shared.js +40 -0
  50. package/dist-es/runtimeExtensions.js +9 -0
  51. package/dist-es/schemas/schemas_0.js +720 -0
  52. package/dist-es/waiters/index.js +2 -0
  53. package/dist-es/waiters/waitForSpaceActive.js +79 -0
  54. package/dist-es/waiters/waitForSpaceDeleted.js +52 -0
  55. package/dist-types/OpenSearchMemory.d.ts +206 -0
  56. package/dist-types/OpenSearchMemoryClient.d.ts +207 -0
  57. package/dist-types/auth/httpAuthExtensionConfiguration.d.ts +29 -0
  58. package/dist-types/auth/httpAuthSchemeProvider.d.ts +75 -0
  59. package/dist-types/commandBuilder.d.ts +22 -0
  60. package/dist-types/commands/BatchGetEventCommand.d.ts +140 -0
  61. package/dist-types/commands/CreateEventCommand.d.ts +134 -0
  62. package/dist-types/commands/CreateMemoryCommand.d.ts +103 -0
  63. package/dist-types/commands/CreateSpaceCommand.d.ts +122 -0
  64. package/dist-types/commands/DeleteEventCommand.d.ts +89 -0
  65. package/dist-types/commands/DeleteMemoryCommand.d.ts +89 -0
  66. package/dist-types/commands/DeleteSpaceCommand.d.ts +90 -0
  67. package/dist-types/commands/GetEventCommand.d.ts +129 -0
  68. package/dist-types/commands/GetMemoryCommand.d.ts +103 -0
  69. package/dist-types/commands/GetSpaceCommand.d.ts +113 -0
  70. package/dist-types/commands/ListEventsCommand.d.ts +105 -0
  71. package/dist-types/commands/ListMemoriesCommand.d.ts +120 -0
  72. package/dist-types/commands/ListSpacesCommand.d.ts +93 -0
  73. package/dist-types/commands/ListTagsForResourceCommand.d.ts +91 -0
  74. package/dist-types/commands/SearchEventsCommand.d.ts +110 -0
  75. package/dist-types/commands/SearchMemoriesCommand.d.ts +120 -0
  76. package/dist-types/commands/TagResourceCommand.d.ts +90 -0
  77. package/dist-types/commands/UntagResourceCommand.d.ts +87 -0
  78. package/dist-types/commands/UpdateMemoryCommand.d.ts +111 -0
  79. package/dist-types/commands/UpdateSpaceCommand.d.ts +112 -0
  80. package/dist-types/commands/index.d.ts +20 -0
  81. package/dist-types/endpoint/EndpointParameters.d.ts +45 -0
  82. package/dist-types/endpoint/bdd.d.ts +2 -0
  83. package/dist-types/endpoint/endpointResolver.d.ts +8 -0
  84. package/dist-types/extensionConfiguration.d.ts +9 -0
  85. package/dist-types/index.d.ts +19 -0
  86. package/dist-types/models/OpenSearchMemoryServiceException.d.ts +15 -0
  87. package/dist-types/models/enums.d.ts +258 -0
  88. package/dist-types/models/errors.d.ts +144 -0
  89. package/dist-types/models/models_0.d.ts +1629 -0
  90. package/dist-types/pagination/Interfaces.d.ts +8 -0
  91. package/dist-types/pagination/ListEventsPaginator.d.ts +7 -0
  92. package/dist-types/pagination/ListMemoriesPaginator.d.ts +7 -0
  93. package/dist-types/pagination/ListSpacesPaginator.d.ts +7 -0
  94. package/dist-types/pagination/SearchEventsPaginator.d.ts +7 -0
  95. package/dist-types/pagination/SearchMemoriesPaginator.d.ts +7 -0
  96. package/dist-types/pagination/index.d.ts +6 -0
  97. package/dist-types/runtimeConfig.browser.d.ts +57 -0
  98. package/dist-types/runtimeConfig.d.ts +58 -0
  99. package/dist-types/runtimeConfig.native.d.ts +56 -0
  100. package/dist-types/runtimeConfig.shared.d.ts +28 -0
  101. package/dist-types/runtimeExtensions.d.ts +17 -0
  102. package/dist-types/schemas/schemas_0.d.ts +105 -0
  103. package/dist-types/ts3.4/OpenSearchMemory.d.ts +371 -0
  104. package/dist-types/ts3.4/OpenSearchMemoryClient.d.ts +190 -0
  105. package/dist-types/ts3.4/auth/httpAuthExtensionConfiguration.d.ts +25 -0
  106. package/dist-types/ts3.4/auth/httpAuthSchemeProvider.d.ts +43 -0
  107. package/dist-types/ts3.4/commandBuilder.d.ts +41 -0
  108. package/dist-types/ts3.4/commands/BatchGetEventCommand.d.ts +38 -0
  109. package/dist-types/ts3.4/commands/CreateEventCommand.d.ts +38 -0
  110. package/dist-types/ts3.4/commands/CreateMemoryCommand.d.ts +38 -0
  111. package/dist-types/ts3.4/commands/CreateSpaceCommand.d.ts +38 -0
  112. package/dist-types/ts3.4/commands/DeleteEventCommand.d.ts +38 -0
  113. package/dist-types/ts3.4/commands/DeleteMemoryCommand.d.ts +38 -0
  114. package/dist-types/ts3.4/commands/DeleteSpaceCommand.d.ts +38 -0
  115. package/dist-types/ts3.4/commands/GetEventCommand.d.ts +38 -0
  116. package/dist-types/ts3.4/commands/GetMemoryCommand.d.ts +38 -0
  117. package/dist-types/ts3.4/commands/GetSpaceCommand.d.ts +38 -0
  118. package/dist-types/ts3.4/commands/ListEventsCommand.d.ts +38 -0
  119. package/dist-types/ts3.4/commands/ListMemoriesCommand.d.ts +38 -0
  120. package/dist-types/ts3.4/commands/ListSpacesCommand.d.ts +38 -0
  121. package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts +39 -0
  122. package/dist-types/ts3.4/commands/SearchEventsCommand.d.ts +38 -0
  123. package/dist-types/ts3.4/commands/SearchMemoriesCommand.d.ts +38 -0
  124. package/dist-types/ts3.4/commands/TagResourceCommand.d.ts +38 -0
  125. package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts +38 -0
  126. package/dist-types/ts3.4/commands/UpdateMemoryCommand.d.ts +38 -0
  127. package/dist-types/ts3.4/commands/UpdateSpaceCommand.d.ts +38 -0
  128. package/dist-types/ts3.4/commands/index.d.ts +20 -0
  129. package/dist-types/ts3.4/endpoint/EndpointParameters.d.ts +46 -0
  130. package/dist-types/ts3.4/endpoint/bdd.d.ts +2 -0
  131. package/dist-types/ts3.4/endpoint/endpointResolver.d.ts +8 -0
  132. package/dist-types/ts3.4/extensionConfiguration.d.ts +10 -0
  133. package/dist-types/ts3.4/index.d.ts +14 -0
  134. package/dist-types/ts3.4/models/OpenSearchMemoryServiceException.d.ts +10 -0
  135. package/dist-types/ts3.4/models/enums.d.ts +73 -0
  136. package/dist-types/ts3.4/models/errors.d.ts +59 -0
  137. package/dist-types/ts3.4/models/models_0.d.ts +459 -0
  138. package/dist-types/ts3.4/pagination/Interfaces.d.ts +5 -0
  139. package/dist-types/ts3.4/pagination/ListEventsPaginator.d.ts +8 -0
  140. package/dist-types/ts3.4/pagination/ListMemoriesPaginator.d.ts +11 -0
  141. package/dist-types/ts3.4/pagination/ListSpacesPaginator.d.ts +8 -0
  142. package/dist-types/ts3.4/pagination/SearchEventsPaginator.d.ts +11 -0
  143. package/dist-types/ts3.4/pagination/SearchMemoriesPaginator.d.ts +11 -0
  144. package/dist-types/ts3.4/pagination/index.d.ts +6 -0
  145. package/dist-types/ts3.4/runtimeConfig.browser.d.ts +93 -0
  146. package/dist-types/ts3.4/runtimeConfig.d.ts +96 -0
  147. package/dist-types/ts3.4/runtimeConfig.native.d.ts +97 -0
  148. package/dist-types/ts3.4/runtimeConfig.shared.d.ts +31 -0
  149. package/dist-types/ts3.4/runtimeExtensions.d.ts +11 -0
  150. package/dist-types/ts3.4/schemas/schemas_0.d.ts +105 -0
  151. package/dist-types/ts3.4/waiters/index.d.ts +2 -0
  152. package/dist-types/ts3.4/waiters/waitForSpaceActive.d.ts +12 -0
  153. package/dist-types/ts3.4/waiters/waitForSpaceDeleted.d.ts +13 -0
  154. package/dist-types/waiters/index.d.ts +2 -0
  155. package/dist-types/waiters/waitForSpaceActive.d.ts +15 -0
  156. package/dist-types/waiters/waitForSpaceDeleted.d.ts +16 -0
  157. package/package.json +67 -4
@@ -0,0 +1,1629 @@
1
+ import type { DocumentType as __DocumentType } from "@smithy/types";
2
+ import type { BatchGetEventErrorCode, BlobContentType, MemorySortField, MemoryStrategyType, MemoryType, MessageRole, MetadataMode, SortOrder, SpaceStatus } from "./enums";
3
+ /**
4
+ * @public
5
+ */
6
+ export interface BatchGetEventInput {
7
+ /**
8
+ * <p>The ID of the space.</p>
9
+ * @public
10
+ */
11
+ spaceId: string | undefined;
12
+ /**
13
+ * <p>The actor that every requested event must belong to. Omit it to skip this check. The operation reports an event that doesn't match in <code>errors</code> as <code>RESOURCE_NOT_FOUND</code>.</p>
14
+ * @public
15
+ */
16
+ actorId?: string | undefined;
17
+ /**
18
+ * <p>The session that every requested event must belong to. Omit it to skip this check. The operation reports an event that doesn't match in <code>errors</code> as <code>RESOURCE_NOT_FOUND</code>.</p>
19
+ * @public
20
+ */
21
+ sessionId?: string | undefined;
22
+ /**
23
+ * <p>The IDs of the events to get: 1 to 10, without duplicates.</p>
24
+ * @public
25
+ */
26
+ eventIds: string[] | undefined;
27
+ }
28
+ /**
29
+ * <p>A requested event that the call didn't return, and the reason.</p>
30
+ * @public
31
+ */
32
+ export interface BatchGetEventError {
33
+ /**
34
+ * <p>The ID of the requested event.</p>
35
+ * @public
36
+ */
37
+ eventId: string | undefined;
38
+ /**
39
+ * <p>The reason that the call didn't return the event.</p>
40
+ * @public
41
+ */
42
+ errorCode: BatchGetEventErrorCode | undefined;
43
+ /**
44
+ * <p>A human-readable description.</p>
45
+ * @public
46
+ */
47
+ message: string | undefined;
48
+ }
49
+ /**
50
+ * <p>An object in Amazon S3.</p>
51
+ * @public
52
+ */
53
+ export interface S3Location {
54
+ /**
55
+ * <p>The object's S3 URI, for example <code>s3://bucket/key</code>. The bucket must be in the space's Region. You need <code>s3:GetObject</code> on the object, and <code>kms:Decrypt</code> on its key if the object uses SSE-KMS. The event doesn't store the object itself.</p>
56
+ * @public
57
+ */
58
+ uri: string | undefined;
59
+ }
60
+ /**
61
+ * <p>The source of a blob's content. Set exactly one member. Currently, the only member is <code>s3Location</code>.</p>
62
+ * @public
63
+ */
64
+ export type BlobSource = BlobSource.S3LocationMember | BlobSource.$UnknownMember;
65
+ /**
66
+ * @public
67
+ */
68
+ export declare namespace BlobSource {
69
+ /**
70
+ * <p>The S3 object holding the document.</p>
71
+ * @public
72
+ */
73
+ interface S3LocationMember {
74
+ s3Location: S3Location;
75
+ $unknown?: never;
76
+ }
77
+ /**
78
+ * @public
79
+ */
80
+ interface $UnknownMember {
81
+ s3Location?: never;
82
+ $unknown: [string, any];
83
+ }
84
+ /**
85
+ * @deprecated unused in schema-serde mode.
86
+ *
87
+ */
88
+ interface Visitor<T> {
89
+ s3Location: (value: S3Location) => T;
90
+ _: (name: string, value: any) => T;
91
+ }
92
+ }
93
+ /**
94
+ * <p>A document stored in Amazon S3, such as a PDF, and its media type.</p>
95
+ * @public
96
+ */
97
+ export interface BlobPayload {
98
+ /**
99
+ * <p>The document's media type. Only <code>application/pdf</code> is supported. Any other value fails with <code>ValidationException</code>.</p>
100
+ * @public
101
+ */
102
+ contentType: BlobContentType | undefined;
103
+ /**
104
+ * <p>The location of the document.</p>
105
+ * @public
106
+ */
107
+ source: BlobSource | undefined;
108
+ }
109
+ /**
110
+ * <p>The content of a conversation turn.</p>
111
+ * @public
112
+ */
113
+ export interface MessageContent {
114
+ /**
115
+ * <p>The text of the turn.</p>
116
+ * @public
117
+ */
118
+ text: string | undefined;
119
+ }
120
+ /**
121
+ * <p>A conversation turn.</p>
122
+ * @public
123
+ */
124
+ export interface Message {
125
+ /**
126
+ * <p>The author of the turn.</p>
127
+ * @public
128
+ */
129
+ role: MessageRole | undefined;
130
+ /**
131
+ * <p>The content of the turn.</p>
132
+ * @public
133
+ */
134
+ content: MessageContent | undefined;
135
+ }
136
+ /**
137
+ * <p>Conversation turns.</p>
138
+ * @public
139
+ */
140
+ export interface UnifiedConversationalObject {
141
+ /**
142
+ * <p>The conversation turns, in order. The order matters for extraction.</p>
143
+ * @public
144
+ */
145
+ messages: Message[] | undefined;
146
+ }
147
+ /**
148
+ * <p>The source of a conversation. Set exactly one member. Currently, the only member is <code>object</code>.</p>
149
+ * @public
150
+ */
151
+ export type UnifiedConversationalSource = UnifiedConversationalSource.ObjectMember | UnifiedConversationalSource.$UnknownMember;
152
+ /**
153
+ * @public
154
+ */
155
+ export declare namespace UnifiedConversationalSource {
156
+ /**
157
+ * <p>The conversation turns.</p>
158
+ * @public
159
+ */
160
+ interface ObjectMember {
161
+ object: UnifiedConversationalObject;
162
+ $unknown?: never;
163
+ }
164
+ /**
165
+ * @public
166
+ */
167
+ interface $UnknownMember {
168
+ object?: never;
169
+ $unknown: [string, any];
170
+ }
171
+ /**
172
+ * @deprecated unused in schema-serde mode.
173
+ *
174
+ */
175
+ interface Visitor<T> {
176
+ object: (value: UnifiedConversationalObject) => T;
177
+ _: (name: string, value: any) => T;
178
+ }
179
+ }
180
+ /**
181
+ * <p>Conversation turns in the service's own format.</p>
182
+ * @public
183
+ */
184
+ export interface UnifiedConversational {
185
+ /**
186
+ * <p>The conversation.</p>
187
+ * @public
188
+ */
189
+ source: UnifiedConversationalSource | undefined;
190
+ }
191
+ /**
192
+ * <p>Conversational content. Exactly one member is set.</p>
193
+ * @public
194
+ */
195
+ export type ConversationalPayload = ConversationalPayload.UnifiedMember | ConversationalPayload.$UnknownMember;
196
+ /**
197
+ * @public
198
+ */
199
+ export declare namespace ConversationalPayload {
200
+ /**
201
+ * <p>Conversation turns in the service's own format.</p>
202
+ * @public
203
+ */
204
+ interface UnifiedMember {
205
+ unified: UnifiedConversational;
206
+ $unknown?: never;
207
+ }
208
+ /**
209
+ * @public
210
+ */
211
+ interface $UnknownMember {
212
+ unified?: never;
213
+ $unknown: [string, any];
214
+ }
215
+ /**
216
+ * @deprecated unused in schema-serde mode.
217
+ *
218
+ */
219
+ interface Visitor<T> {
220
+ unified: (value: UnifiedConversational) => T;
221
+ _: (name: string, value: any) => T;
222
+ }
223
+ }
224
+ /**
225
+ * <p>The source of structured content. Set exactly one member. Currently, the only member is <code>json</code>.</p>
226
+ * @public
227
+ */
228
+ export type StructuredDataSource = StructuredDataSource.JsonMember | StructuredDataSource.$UnknownMember;
229
+ /**
230
+ * @public
231
+ */
232
+ export declare namespace StructuredDataSource {
233
+ /**
234
+ * <p>The structured content, as a JSON object of at most 1 MiB when serialized as UTF-8, nested at most 10 levels deep.</p>
235
+ * @public
236
+ */
237
+ interface JsonMember {
238
+ json: __DocumentType;
239
+ $unknown?: never;
240
+ }
241
+ /**
242
+ * @public
243
+ */
244
+ interface $UnknownMember {
245
+ json?: never;
246
+ $unknown: [string, any];
247
+ }
248
+ /**
249
+ * @deprecated unused in schema-serde mode.
250
+ *
251
+ */
252
+ interface Visitor<T> {
253
+ json: (value: __DocumentType) => T;
254
+ _: (name: string, value: any) => T;
255
+ }
256
+ }
257
+ /**
258
+ * <p>Structured content, as a JSON object.</p>
259
+ * @public
260
+ */
261
+ export interface StructuredDataPayload {
262
+ /**
263
+ * <p>The structured content.</p>
264
+ * @public
265
+ */
266
+ source: StructuredDataSource | undefined;
267
+ }
268
+ /**
269
+ * <p>The event content. Exactly one member must be set.</p>
270
+ * @public
271
+ */
272
+ export type EventPayload = EventPayload.BlobMember | EventPayload.ConversationalMember | EventPayload.StructuredDataMember | EventPayload.$UnknownMember;
273
+ /**
274
+ * @public
275
+ */
276
+ export declare namespace EventPayload {
277
+ /**
278
+ * <p>Conversation turns.</p>
279
+ * @public
280
+ */
281
+ interface ConversationalMember {
282
+ conversational: ConversationalPayload;
283
+ structuredData?: never;
284
+ blob?: never;
285
+ $unknown?: never;
286
+ }
287
+ /**
288
+ * <p>Structured (non-conversational) content, for example a deployment result that an agent should remember.</p>
289
+ * @public
290
+ */
291
+ interface StructuredDataMember {
292
+ conversational?: never;
293
+ structuredData: StructuredDataPayload;
294
+ blob?: never;
295
+ $unknown?: never;
296
+ }
297
+ /**
298
+ * <p>A document stored in Amazon S3, such as a PDF.</p>
299
+ * @public
300
+ */
301
+ interface BlobMember {
302
+ conversational?: never;
303
+ structuredData?: never;
304
+ blob: BlobPayload;
305
+ $unknown?: never;
306
+ }
307
+ /**
308
+ * @public
309
+ */
310
+ interface $UnknownMember {
311
+ conversational?: never;
312
+ structuredData?: never;
313
+ blob?: never;
314
+ $unknown: [string, any];
315
+ }
316
+ /**
317
+ * @deprecated unused in schema-serde mode.
318
+ *
319
+ */
320
+ interface Visitor<T> {
321
+ conversational: (value: ConversationalPayload) => T;
322
+ structuredData: (value: StructuredDataPayload) => T;
323
+ blob: (value: BlobPayload) => T;
324
+ _: (name: string, value: any) => T;
325
+ }
326
+ }
327
+ /**
328
+ * <p>An event, including its payload.</p>
329
+ * @public
330
+ */
331
+ export interface Event {
332
+ /**
333
+ * <p>The event's ID.</p>
334
+ * @public
335
+ */
336
+ eventId: string | undefined;
337
+ /**
338
+ * <p>The ID of the space.</p>
339
+ * @public
340
+ */
341
+ spaceId: string | undefined;
342
+ /**
343
+ * <p>The ID of the actor the event belongs to.</p>
344
+ * @public
345
+ */
346
+ actorId: string | undefined;
347
+ /**
348
+ * <p>The ID of the session the event belongs to.</p>
349
+ * @public
350
+ */
351
+ sessionId: string | undefined;
352
+ /**
353
+ * <p>The event's content, as submitted to <code>CreateEvent</code>.</p>
354
+ * @public
355
+ */
356
+ payload: EventPayload | undefined;
357
+ /**
358
+ * <p>The event's metadata tags, as supplied to <code>CreateEvent</code>. May be empty.</p>
359
+ * @public
360
+ */
361
+ metadata?: Record<string, string> | undefined;
362
+ /**
363
+ * <p>The time the event occurred.</p>
364
+ * @public
365
+ */
366
+ eventTimestamp: Date | undefined;
367
+ }
368
+ /**
369
+ * @public
370
+ */
371
+ export interface BatchGetEventOutput {
372
+ /**
373
+ * <p>The events found, in the order that you requested their IDs.</p>
374
+ * @public
375
+ */
376
+ events: Event[] | undefined;
377
+ /**
378
+ * <p>An entry for each requested event that the call didn't return. Empty when the call returned every event.</p>
379
+ * @public
380
+ */
381
+ errors: BatchGetEventError[] | undefined;
382
+ }
383
+ /**
384
+ * <p>Information about a request field that failed validation.</p>
385
+ * @public
386
+ */
387
+ export interface ValidationExceptionField {
388
+ /**
389
+ * <p>The field name.</p>
390
+ * @public
391
+ */
392
+ name: string | undefined;
393
+ /**
394
+ * <p>A message that describes why the field failed validation.</p>
395
+ * @public
396
+ */
397
+ message: string | undefined;
398
+ }
399
+ /**
400
+ * @public
401
+ */
402
+ export interface CreateEventInput {
403
+ /**
404
+ * <p>The ID of the space that owns the event, for example <code>sp-02864597b164</code>.</p>
405
+ * @public
406
+ */
407
+ spaceId: string | undefined;
408
+ /**
409
+ * <p>The ID of the actor (end user or agent) that the event belongs to.</p>
410
+ * @public
411
+ */
412
+ actorId: string | undefined;
413
+ /**
414
+ * <p>The session the event belongs to. Send every event of one conversation with the same session ID, so that <code>SUMMARY</code> strategies summarize the conversation as one session. If you omit it, the service generates a session ID and returns it.</p>
415
+ * @public
416
+ */
417
+ sessionId?: string | undefined;
418
+ /**
419
+ * <p>When the event occurred. The default is the time that the service receives the request.</p>
420
+ * @public
421
+ */
422
+ eventTimestamp?: Date | undefined;
423
+ /**
424
+ * <p>The event content. Set exactly one union member.</p>
425
+ * @public
426
+ */
427
+ payload: EventPayload | undefined;
428
+ /**
429
+ * <p>Metadata tags to store with the event. Memories derived from the event carry the same tags. Keys that begin with <code>x-amz-</code>, the keys <code>documentS3Source</code> and <code>documentS3Url</code>, and other keys that the service uses internally are reserved: a request that sets one fails with <code>ValidationException</code>, and the message names the key.</p> <p>A space can use at most 50 distinct metadata keys across all of its events and memories. A request that would add a key beyond that fails with <code>ValidationException</code>. Reuse an existing key instead.</p>
430
+ * @public
431
+ */
432
+ metadata?: Record<string, string> | undefined;
433
+ /**
434
+ * <p>A unique, case-sensitive identifier that makes the request idempotent. Within 2 hours of the first request, a retry with the same token and the same request, including the same <code>sessionId</code>, returns the same event. If you omit <code>sessionId</code>, the service generates a new one on each attempt, so a retry fails with <code>ConflictException</code>. Reusing the token with different request content also fails with <code>ConflictException</code>. <code>eventTimestamp</code> isn't compared. After 2 hours, the token starts a new event.</p>
435
+ * @public
436
+ */
437
+ clientToken?: string | undefined;
438
+ /**
439
+ * <p>Specifies whether to extract memories from this event. The default is <code>true</code>. Set it to <code>false</code> to store the event without extraction: the service skips strategies that infer memories, and still indexes the event's turns for <code>SearchEvents</code>. A document submitted as a <code>blob</code> is still extracted.</p>
440
+ * @public
441
+ */
442
+ infer?: boolean | undefined;
443
+ }
444
+ /**
445
+ * <p>The stored event's identifiers. Call <code>GetEvent</code> for the payload.</p>
446
+ * @public
447
+ */
448
+ export interface EventDetail {
449
+ /**
450
+ * <p>The event's ID, assigned by the service. Use it with <code>GetEvent</code> and <code>DeleteEvent</code>.</p>
451
+ * @public
452
+ */
453
+ eventId: string | undefined;
454
+ /**
455
+ * <p>The ID of the space.</p>
456
+ * @public
457
+ */
458
+ spaceId: string | undefined;
459
+ /**
460
+ * <p>The ID of the actor the event belongs to.</p>
461
+ * @public
462
+ */
463
+ actorId: string | undefined;
464
+ /**
465
+ * <p>The ID of the session the event belongs to, including one the service generated.</p>
466
+ * @public
467
+ */
468
+ sessionId: string | undefined;
469
+ /**
470
+ * <p>When the event occurred: the value supplied, or the time the request was received.</p>
471
+ * @public
472
+ */
473
+ eventTimestamp: Date | undefined;
474
+ }
475
+ /**
476
+ * @public
477
+ */
478
+ export interface CreateEventOutput {
479
+ /**
480
+ * <p>The stored event's identifiers: its ID, session, and timestamp.</p>
481
+ * @public
482
+ */
483
+ event: EventDetail | undefined;
484
+ }
485
+ /**
486
+ * <p>The request for <code>CreateMemory</code>.</p>
487
+ * @public
488
+ */
489
+ export interface CreateMemoryInput {
490
+ /**
491
+ * <p>The ID of the space that owns the memory, for example <code>sp-02864597b164</code>.</p>
492
+ * @public
493
+ */
494
+ spaceId: string | undefined;
495
+ /**
496
+ * <p>The name of the strategy that the memory belongs to. The space must already declare the strategy, and the memory's type comes from that strategy. The name must be 1 to 64 characters: letters, digits, periods, hyphens, and underscores, starting with a letter or digit.</p>
497
+ * @public
498
+ */
499
+ name: string | undefined;
500
+ /**
501
+ * <p>The memory text, stored and embedded as provided.</p>
502
+ * @public
503
+ */
504
+ content: string | undefined;
505
+ /**
506
+ * <p>The actor (end user or agent) that owns the memory.</p>
507
+ * @public
508
+ */
509
+ actorId: string | undefined;
510
+ /**
511
+ * <p>The session that the memory belongs to. If you omit it, the service generates a session ID and returns it.</p>
512
+ * @public
513
+ */
514
+ sessionId?: string | undefined;
515
+ /**
516
+ * <p>Metadata tags to store with the memory. Keys that begin with <code>x-amz-</code>, the key <code>documentS3Source</code>, and other keys that the service uses internally are reserved: a request that sets one fails with <code>ValidationException</code>, and the message names the key.</p> <p>A space can use at most 50 distinct metadata keys across all of its events and memories. A request that would add a key beyond that fails with <code>ValidationException</code>. Reuse an existing key instead.</p>
517
+ * @public
518
+ */
519
+ metadata?: Record<string, string> | undefined;
520
+ /**
521
+ * <p>A unique, case-sensitive identifier that makes the request idempotent. Within 2 hours of the first request, a retry with the same token returns the same <code>memoryId</code> instead of creating a second memory. Reusing the token with a different <code>name</code>, <code>content</code>, <code>metadata</code>, <code>actorId</code>, or <code>sessionId</code> fails with <code>ConflictException</code>. If you omit <code>sessionId</code>, a retry with the same token gets the same session. If you omit the token, each call creates a new memory.</p>
522
+ * @public
523
+ */
524
+ clientToken?: string | undefined;
525
+ }
526
+ /**
527
+ * <p>The memory as <code>CreateMemory</code> acknowledges it: its identifiers. The memory isn't searchable yet when the call returns.</p>
528
+ * @public
529
+ */
530
+ export interface CreateMemoryDetail {
531
+ /**
532
+ * <p>The final ID of the memory. Until the memory is indexed, <code>GetMemory</code>, <code>UpdateMemory</code>, and <code>DeleteMemory</code> return <code>ResourceNotFoundException</code> for it.</p>
533
+ * @public
534
+ */
535
+ memoryId: string | undefined;
536
+ /**
537
+ * <p>The ID of the space.</p>
538
+ * @public
539
+ */
540
+ spaceId: string | undefined;
541
+ /**
542
+ * <p>The name of the strategy the memory belongs to.</p>
543
+ * @public
544
+ */
545
+ name: string | undefined;
546
+ /**
547
+ * <p>The ID of the actor the memory belongs to.</p>
548
+ * @public
549
+ */
550
+ actorId: string | undefined;
551
+ /**
552
+ * <p>The ID of the session the memory belongs to, including one the service generated.</p>
553
+ * @public
554
+ */
555
+ sessionId: string | undefined;
556
+ }
557
+ /**
558
+ * <p>The acknowledged memory. It isn't searchable yet when the call returns.</p>
559
+ * @public
560
+ */
561
+ export interface CreateMemoryOutput {
562
+ /**
563
+ * <p>The memory, identified but not yet indexed.</p>
564
+ * @public
565
+ */
566
+ memory: CreateMemoryDetail | undefined;
567
+ }
568
+ /**
569
+ * <p>Encryption settings for a space.</p>
570
+ * @public
571
+ */
572
+ export interface EncryptionConfiguration {
573
+ /**
574
+ * <p>The ARN of a customer managed AWS KMS key that encrypts the space's data. The key must be an enabled symmetric encryption key in the space's Region, and you need permission to create grants on it (<code>kms:CreateGrant</code>). Otherwise, the request fails with <code>ValidationException</code> or <code>AccessDeniedException</code>.</p>
575
+ * @public
576
+ */
577
+ kmsKeyArn?: string | undefined;
578
+ }
579
+ /**
580
+ * <p>Settings for a memory strategy. The defaults described here apply when you create a strategy. In <code>UpdateSpace</code>, a member you omit for a kept strategy keeps its current value.</p>
581
+ * @public
582
+ */
583
+ export interface MemoryStrategyConfiguration {
584
+ /**
585
+ * <p>Instructions that define what a <code>CUSTOM</code> strategy extracts, up to 30,720 characters. Required for a <code>CUSTOM</code> strategy: <code>CreateSpace</code> and <code>UpdateSpace</code> fail with <code>ValidationException</code> if a <code>CUSTOM</code> strategy has none.</p> <p>Only <code>CUSTOM</code> strategies use it. <code>SEMANTIC</code> and <code>SUMMARY</code> strategies always extract with the service's built-in instructions: the service accepts and stores a prompt on them, and <code>GetSpace</code> returns it, but extraction doesn't use it.</p>
586
+ * @public
587
+ */
588
+ extractionPrompt?: string | undefined;
589
+ /**
590
+ * <p>Extract once this many messages have accumulated, from 1 to 1000. Lower values extract more often, in smaller batches. The default is 12.</p> <p>Messages accumulate until the first of <code>extractEveryNMessages</code>, <code>extractEveryNTokens</code>, and <code>idleTimeoutSeconds</code> is reached. The service then extracts them together in one pass.</p>
591
+ * @public
592
+ */
593
+ extractEveryNMessages?: number | undefined;
594
+ /**
595
+ * <p>Extract once this many tokens of conversation have accumulated, from 1 to 80,000, however few messages that takes. Use it to bound how much text one extraction call carries when message sizes vary widely. Omit it to bound a batch only by <code>extractEveryNMessages</code>, <code>idleTimeoutSeconds</code>, and the service's maximum batch size.</p>
596
+ * @public
597
+ */
598
+ extractEveryNTokens?: number | undefined;
599
+ /**
600
+ * <p>Extract what has accumulated once the conversation has been idle for this many seconds, from 1 to 86,400. The default is 60. This is what extracts the end of a conversation that stops. Raise it when the pauses in your conversations are longer than that, so that one exchange isn't split across several extraction passes.</p>
601
+ * @public
602
+ */
603
+ idleTimeoutSeconds?: number | undefined;
604
+ /**
605
+ * <p>How many of the strategy's stored memories that are most relevant to the conversation to include in the extraction prompt, from 0 to 20, to improve extraction and reduce duplicates. If you omit this or set it to 0, the service uses its default (see <code>extractionSeedRecentN</code>). When this and <code>extractionSeedRecentN</code> are both set, the two sets of memories are combined without duplicates.</p>
606
+ * @public
607
+ */
608
+ extractionSeedTopK?: number | undefined;
609
+ /**
610
+ * <p>How many of the strategy's most recent stored memories to include in the extraction prompt, from 0 to 20. If you omit this or set it to 0, the service uses its default: no seeding for most strategy types, and the 10 most recent memories for a <code>SUMMARY</code> strategy when neither seed setting is given. When this and <code>extractionSeedTopK</code> are both set, the two sets of memories are combined without duplicates.</p>
611
+ * @public
612
+ */
613
+ extractionSeedRecentN?: number | undefined;
614
+ /**
615
+ * <p>Specifies whether the strategy consolidates memories. With consolidation, each new memory is compared with similar stored memories, and the service adds it, updates a stored memory, or skips it, so duplicate or contradicting facts don't accumulate. Without it, every extracted memory is stored as a new memory, which costs less and keeps a full history.</p> <p>When omitted, the default depends on the strategy's type: on for <code>SEMANTIC</code> and <code>SUMMARY</code>, off for <code>CUSTOM</code>.</p>
616
+ * @public
617
+ */
618
+ consolidationEnabled?: boolean | undefined;
619
+ }
620
+ /**
621
+ * <p>A memory strategy: how a space extracts one kind of memory from its events.</p>
622
+ * @public
623
+ */
624
+ export interface MemoryStrategy {
625
+ /**
626
+ * <p>The type of memory the strategy extracts.</p>
627
+ * @public
628
+ */
629
+ type: MemoryStrategyType | undefined;
630
+ /**
631
+ * <p>A name for the strategy, unique within the space. Omit it to have the service generate one from the type, for example <code>semantic_1</code>. The name must be 1 to 64 characters: letters, digits, periods, hyphens, and underscores, starting with a letter or digit. A strategy's name can't be changed, and the strategy's memories are stored under it: a strategy added under a new name starts with no memories.</p>
632
+ * @public
633
+ */
634
+ name?: string | undefined;
635
+ /**
636
+ * <p>A description of the strategy.</p>
637
+ * @public
638
+ */
639
+ description?: string | undefined;
640
+ /**
641
+ * <p>Settings for the strategy. When you create a strategy, omit it to use the defaults for the strategy's type.</p> <p>A <code>CUSTOM</code> strategy must set <code>extractionPrompt</code>.</p>
642
+ * @public
643
+ */
644
+ configuration?: MemoryStrategyConfiguration | undefined;
645
+ }
646
+ /**
647
+ * <p>A tag: a key-value pair that you attach to a space.</p>
648
+ * @public
649
+ */
650
+ export interface Tag {
651
+ /**
652
+ * <p>The key of the tag.</p>
653
+ * @public
654
+ */
655
+ key: string | undefined;
656
+ /**
657
+ * <p>The value of the tag.</p>
658
+ * @public
659
+ */
660
+ value: string | undefined;
661
+ }
662
+ /**
663
+ * @public
664
+ */
665
+ export interface CreateSpaceRequest {
666
+ /**
667
+ * <p>A name for the space, unique within your account in the Region. If another space already has the name, the request fails with <code>ConflictException</code>.</p>
668
+ * @public
669
+ */
670
+ name: string | undefined;
671
+ /**
672
+ * <p>The memory strategies that extract memories from the space's events: up to 10 strategies, each with a name that is unique within the space.</p> <p>Optional. Omit it, or send an empty list, to create a space with no memory strategies. Such a space stores the conversation events you send it and returns them through <code>SearchEvents</code> and <code>ListEvents</code>, but extracts no memories and has none to search. You can add strategies later with <code>UpdateSpace</code>.</p> <p>The serialized list can be at most 384 KiB.</p>
673
+ * @public
674
+ */
675
+ memoryStrategies?: MemoryStrategy[] | undefined;
676
+ /**
677
+ * <p>How many days the space keeps each event, from 1 to 365. The default is 90.</p>
678
+ * @public
679
+ */
680
+ eventExpiryDays?: number | undefined;
681
+ /**
682
+ * <p>How many days the space keeps each memory, from 0 to 3650, counted from when the service writes the memory. Updating a memory with <code>UpdateMemory</code> doesn't restart the count. 0 means memories never expire. If you omit it, memories never expire.</p> <p>Searches and lists leave out a memory past its expiry, and reading, updating, or deleting it returns <code>ResourceNotFoundException</code>.</p>
683
+ * @public
684
+ */
685
+ memoryExpiryDays?: number | undefined;
686
+ /**
687
+ * <p>The model that extracts and consolidates memories for every strategy in the space, as an Amazon Bedrock model ID without an inference-profile prefix: <code>anthropic.claude-opus-5-5</code> or <code>anthropic.claude-haiku-5-5</code>. Another value fails with <code>ValidationException</code>, and the message lists the supported IDs. Omit it to use the service default, which can change over time and isn't returned by <code>GetSpace</code>. Setting a value pins the model.</p>
688
+ * @public
689
+ */
690
+ extractionModelId?: string | undefined;
691
+ /**
692
+ * <p>The AWS KMS key that encrypts the space's data. Omit it, or omit its <code>kmsKeyArn</code>, to use an AWS owned key. You can't change the key after you create the space.</p>
693
+ * @public
694
+ */
695
+ encryptionConfiguration?: EncryptionConfiguration | undefined;
696
+ /**
697
+ * <p>The tags to add to the space.</p>
698
+ * @public
699
+ */
700
+ tags?: Tag[] | undefined;
701
+ /**
702
+ * <p>A unique, case-sensitive identifier that makes the request idempotent. A retry with the same token and the same parameters within 2 hours returns the space that the first request created, instead of creating another. Reusing the token with different parameters, or while the first request is still in progress, fails with <code>ConflictException</code>.</p>
703
+ * @public
704
+ */
705
+ clientToken?: string | undefined;
706
+ }
707
+ /**
708
+ * @public
709
+ */
710
+ export interface CreateSpaceResponse {
711
+ /**
712
+ * <p>The ID of the space.</p>
713
+ * @public
714
+ */
715
+ spaceId: string | undefined;
716
+ /**
717
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
718
+ * @public
719
+ */
720
+ arn: string | undefined;
721
+ /**
722
+ * <p>The name of the space.</p>
723
+ * @public
724
+ */
725
+ name: string | undefined;
726
+ /**
727
+ * <p>The status of the space: <code>CREATING</code>.</p>
728
+ * @public
729
+ */
730
+ status: SpaceStatus | undefined;
731
+ /**
732
+ * <p>When the space was created.</p>
733
+ * @public
734
+ */
735
+ createdAt: Date | undefined;
736
+ }
737
+ /**
738
+ * @public
739
+ */
740
+ export interface DeleteEventInput {
741
+ /**
742
+ * <p>The ID of the space.</p>
743
+ * @public
744
+ */
745
+ spaceId: string | undefined;
746
+ /**
747
+ * <p>The ID of the event to delete.</p>
748
+ * @public
749
+ */
750
+ eventId: string | undefined;
751
+ /**
752
+ * <p>The actor that the event must belong to. Omit it to skip this check. If it doesn't match the stored event, the call fails with <code>ResourceNotFoundException</code>, as if the event did not exist.</p>
753
+ * @public
754
+ */
755
+ actorId?: string | undefined;
756
+ /**
757
+ * <p>The session that the event must belong to. Omit it to skip this check. If it doesn't match the stored event, the call fails with <code>ResourceNotFoundException</code>, as if the event did not exist.</p>
758
+ * @public
759
+ */
760
+ sessionId?: string | undefined;
761
+ }
762
+ /**
763
+ * @public
764
+ */
765
+ export interface DeleteEventOutput {
766
+ /**
767
+ * <p>The ID of the deleted event.</p>
768
+ * @public
769
+ */
770
+ eventId: string | undefined;
771
+ }
772
+ /**
773
+ * @public
774
+ */
775
+ export interface DeleteMemoryInput {
776
+ /**
777
+ * <p>The ID of the space that owns the memory.</p>
778
+ * @public
779
+ */
780
+ spaceId: string | undefined;
781
+ /**
782
+ * <p>The ID of the memory to delete.</p>
783
+ * @public
784
+ */
785
+ memoryId: string | undefined;
786
+ /**
787
+ * <p>The ID of the actor that the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
788
+ * @public
789
+ */
790
+ actorId?: string | undefined;
791
+ /**
792
+ * <p>The name of the strategy that the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
793
+ * @public
794
+ */
795
+ strategyName?: string | undefined;
796
+ }
797
+ /**
798
+ * @public
799
+ */
800
+ export interface DeleteMemoryOutput {
801
+ /**
802
+ * <p>The ID of the deleted memory.</p>
803
+ * @public
804
+ */
805
+ memoryId: string | undefined;
806
+ }
807
+ /**
808
+ * @public
809
+ */
810
+ export interface DeleteSpaceRequest {
811
+ /**
812
+ * <p>The ID of the space to delete.</p>
813
+ * @public
814
+ */
815
+ spaceId: string | undefined;
816
+ }
817
+ /**
818
+ * @public
819
+ */
820
+ export interface DeleteSpaceResponse {
821
+ /**
822
+ * <p>The ID of the space.</p>
823
+ * @public
824
+ */
825
+ spaceId: string | undefined;
826
+ /**
827
+ * <p>The status of the space: <code>DELETING</code>.</p>
828
+ * @public
829
+ */
830
+ status: SpaceStatus | undefined;
831
+ }
832
+ /**
833
+ * <p>System-generated provenance for a memory or event: the owning actor and session, and the creation and last-update timestamps. <code>SearchMemories</code>, <code>SearchEvents</code>, <code>ListMemories</code>, and <code>GetMemory</code> return the same block.</p> <p> <code>ListMemories</code> and <code>GetMemory</code> always return <code>createdAt</code> and <code>updatedAt</code>. The search operations return what is recorded and omit the block when nothing is.</p> <p>In a query, the timestamps are <code>system_metadata.created_at</code> and <code>system_metadata.updated_at</code>. Scope by owner with the top-level parameters (<code>actorId</code> on the search operations, <code>actorIds</code> on <code>ListMemories</code>) and <code>sessionIds</code> (<code>SearchEvents</code> and <code>ListMemories</code>). The search operations reject actor and session fields inside the query or sort.</p>
834
+ * @public
835
+ */
836
+ export interface SystemMetadata {
837
+ /**
838
+ * <p>The owning actor. Absent when none was recorded.</p>
839
+ * @public
840
+ */
841
+ actorId?: string | undefined;
842
+ /**
843
+ * <p>The owning session. Absent when none was recorded.</p>
844
+ * @public
845
+ */
846
+ sessionId?: string | undefined;
847
+ /**
848
+ * <p>When the record was created. Always present on <code>ListMemories</code> and <code>GetMemory</code>. It can be absent from search results.</p>
849
+ * @public
850
+ */
851
+ createdAt?: Date | undefined;
852
+ /**
853
+ * <p>When the record was last updated. Equals <code>createdAt</code> for a record that has never been updated, and always for a <code>SearchEvents</code> result.</p>
854
+ * @public
855
+ */
856
+ updatedAt?: Date | undefined;
857
+ }
858
+ /**
859
+ * <p>A <code>SearchEvents</code> result: the matching chunk of an event and its provenance. Unlike <code>EventSummary</code> from <code>ListEvents</code>, it has a relevance score and the matched content, but not the full payload.</p>
860
+ * @public
861
+ */
862
+ export interface EventSearchSummary {
863
+ /**
864
+ * <p>The ID of the event that the chunk belongs to. Use it with <code>GetEvent</code> or <code>DeleteEvent</code>.</p>
865
+ * @public
866
+ */
867
+ eventId: string | undefined;
868
+ /**
869
+ * <p>The relevance score of the result. A higher score is more relevant. Scores aren't normalized to a fixed range and can be greater than 1, so use them only to order results.</p>
870
+ * @public
871
+ */
872
+ score?: number | undefined;
873
+ /**
874
+ * <p>Provenance for the chunk: the owning actor and session, and when it was created and last updated. It is the same block that <code>ListMemories</code> and <code>SearchMemories</code> return. Event chunks are never modified, so <code>updatedAt</code> always equals <code>createdAt</code>.</p> <p>Absent when the service has no provenance for the chunk.</p>
875
+ * @public
876
+ */
877
+ systemMetadata?: SystemMetadata | undefined;
878
+ /**
879
+ * <p>The event's metadata tags. All values are strings. In a query, filter on a tag as <code>metadata.&lt;key&gt;</code>.</p>
880
+ * @public
881
+ */
882
+ metadata?: Record<string, string> | undefined;
883
+ /**
884
+ * <p>The text of the matching chunk.</p>
885
+ * @public
886
+ */
887
+ matchedContent?: string | undefined;
888
+ }
889
+ /**
890
+ * <p>A summary of an event, as returned by <code>ListEvents</code>. It doesn't include the payload.</p>
891
+ * @public
892
+ */
893
+ export interface EventSummary {
894
+ /**
895
+ * <p>The event's ID.</p>
896
+ * @public
897
+ */
898
+ eventId: string | undefined;
899
+ /**
900
+ * <p>The event's metadata tags, as supplied to <code>CreateEvent</code>. May be empty.</p>
901
+ * @public
902
+ */
903
+ metadata?: Record<string, string> | undefined;
904
+ /**
905
+ * <p>The time the event occurred.</p>
906
+ * @public
907
+ */
908
+ eventTimestamp: Date | undefined;
909
+ }
910
+ /**
911
+ * @public
912
+ */
913
+ export interface GetEventInput {
914
+ /**
915
+ * <p>The ID of the space.</p>
916
+ * @public
917
+ */
918
+ spaceId: string | undefined;
919
+ /**
920
+ * <p>The event's ID, as returned by <code>CreateEvent</code>, <code>ListEvents</code>, or <code>SearchEvents</code>.</p>
921
+ * @public
922
+ */
923
+ eventId: string | undefined;
924
+ /**
925
+ * <p>The actor the event must belong to. Omit it to skip this check. If it doesn't match the stored event, the call fails with <code>ResourceNotFoundException</code>, as if the event did not exist.</p>
926
+ * @public
927
+ */
928
+ actorId?: string | undefined;
929
+ /**
930
+ * <p>The session the event must belong to. Omit it to skip this check. If it doesn't match the stored event, the call fails with <code>ResourceNotFoundException</code>, as if the event did not exist.</p>
931
+ * @public
932
+ */
933
+ sessionId?: string | undefined;
934
+ }
935
+ /**
936
+ * @public
937
+ */
938
+ export interface GetEventOutput {
939
+ /**
940
+ * <p>The event, including its payload.</p>
941
+ * @public
942
+ */
943
+ event: Event | undefined;
944
+ }
945
+ /**
946
+ * @public
947
+ */
948
+ export interface GetMemoryInput {
949
+ /**
950
+ * <p>The ID of the space that holds the memory.</p>
951
+ * @public
952
+ */
953
+ spaceId: string | undefined;
954
+ /**
955
+ * <p>The memory's ID, as returned by <code>SearchMemories</code> or <code>ListMemories</code>.</p>
956
+ * @public
957
+ */
958
+ memoryId: string | undefined;
959
+ /**
960
+ * <p>The ID of the actor the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
961
+ * @public
962
+ */
963
+ actorId?: string | undefined;
964
+ /**
965
+ * <p>The name of the strategy the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
966
+ * @public
967
+ */
968
+ strategyName?: string | undefined;
969
+ }
970
+ /**
971
+ * <p>A memory, as returned by <code>GetMemory</code> and <code>UpdateMemory</code>. Unlike <code>MemoryListSummary</code> it includes <code>content</code>, and unlike <code>MemorySearchSummary</code> it has no relevance score.</p>
972
+ * @public
973
+ */
974
+ export interface Memory {
975
+ /**
976
+ * <p>The memory's ID, assigned by the service.</p>
977
+ * @public
978
+ */
979
+ memoryId: string | undefined;
980
+ /**
981
+ * <p>The memory type.</p>
982
+ * @public
983
+ */
984
+ memoryType: MemoryType | undefined;
985
+ /**
986
+ * <p>The name of the strategy the memory belongs to, for example <code>user-facts</code>. A space can hold several strategies of the same type, so this tells them apart. Absent when the memory's strategy is no longer declared on the space, for example right after the strategy is deleted.</p>
987
+ * @public
988
+ */
989
+ strategyName?: string | undefined;
990
+ /**
991
+ * <p>The memory text.</p>
992
+ * @public
993
+ */
994
+ content: string | undefined;
995
+ /**
996
+ * <p>Provenance for the memory: the owning actor and session, and when it was created and last updated. Always present. <code>updatedAt</code> equals <code>createdAt</code> for a memory that has never been updated.</p>
997
+ * @public
998
+ */
999
+ systemMetadata: SystemMetadata | undefined;
1000
+ /**
1001
+ * <p>The memory's metadata tags. All values are strings. May be empty.</p>
1002
+ * @public
1003
+ */
1004
+ metadata?: Record<string, string> | undefined;
1005
+ }
1006
+ /**
1007
+ * @public
1008
+ */
1009
+ export interface GetMemoryOutput {
1010
+ /**
1011
+ * <p>The memory. Always present: a memory that doesn't exist returns <code>ResourceNotFoundException</code>.</p>
1012
+ * @public
1013
+ */
1014
+ memory: Memory | undefined;
1015
+ }
1016
+ /**
1017
+ * @public
1018
+ */
1019
+ export interface GetSpaceRequest {
1020
+ /**
1021
+ * <p>The ID of the space.</p>
1022
+ * @public
1023
+ */
1024
+ spaceId: string | undefined;
1025
+ }
1026
+ /**
1027
+ * @public
1028
+ */
1029
+ export interface GetSpaceResponse {
1030
+ /**
1031
+ * <p>The ID of the space.</p>
1032
+ * @public
1033
+ */
1034
+ spaceId: string | undefined;
1035
+ /**
1036
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
1037
+ * @public
1038
+ */
1039
+ arn: string | undefined;
1040
+ /**
1041
+ * <p>The name of the space.</p>
1042
+ * @public
1043
+ */
1044
+ name: string | undefined;
1045
+ /**
1046
+ * <p>The status of the space.</p>
1047
+ * @public
1048
+ */
1049
+ status: SpaceStatus | undefined;
1050
+ /**
1051
+ * <p>Details about why the space is <code>FAILED</code>. Read it only when <code>status</code> is <code>FAILED</code>: it can still hold the reason for an earlier failure.</p>
1052
+ * @public
1053
+ */
1054
+ statusReason?: string | undefined;
1055
+ /**
1056
+ * <p>When the space was created.</p>
1057
+ * @public
1058
+ */
1059
+ createdAt: Date | undefined;
1060
+ /**
1061
+ * <p>The space's memory strategies, including the names the service generated for strategies created without one. Empty for a space that has no memory strategies.</p>
1062
+ * @public
1063
+ */
1064
+ memoryStrategies?: MemoryStrategy[] | undefined;
1065
+ /**
1066
+ * <p>How many days the space keeps each event. Absent when it was never set, in which case the default of 90 days applies.</p>
1067
+ * @public
1068
+ */
1069
+ eventExpiryDays?: number | undefined;
1070
+ /**
1071
+ * <p>How many days the space keeps each memory. 0 means memories never expire. Absent when it was never set, in which case memories never expire.</p>
1072
+ * @public
1073
+ */
1074
+ memoryExpiryDays?: number | undefined;
1075
+ /**
1076
+ * <p>The model that extracts and consolidates memories for the space. Absent when it was never set, in which case the service default applies.</p>
1077
+ * @public
1078
+ */
1079
+ extractionModelId?: string | undefined;
1080
+ /**
1081
+ * <p>The AWS KMS key the space was created with. Absent when the space uses an AWS owned key.</p>
1082
+ * @public
1083
+ */
1084
+ encryptionConfiguration?: EncryptionConfiguration | undefined;
1085
+ }
1086
+ /**
1087
+ * @public
1088
+ */
1089
+ export interface ListEventsInput {
1090
+ /**
1091
+ * <p>The ID of the space.</p>
1092
+ * @public
1093
+ */
1094
+ spaceId: string | undefined;
1095
+ /**
1096
+ * <p>The actor whose events to list.</p>
1097
+ * @public
1098
+ */
1099
+ actorId: string | undefined;
1100
+ /**
1101
+ * <p>The session whose events to list. To find events across sessions, use <code>SearchEvents</code>.</p>
1102
+ * @public
1103
+ */
1104
+ sessionId: string | undefined;
1105
+ /**
1106
+ * <p>Inclusive upper bound on <code>eventTimestamp</code>: only events at or before this time are returned. Omit for no upper bound.</p>
1107
+ * @public
1108
+ */
1109
+ eventTimestampBefore?: Date | undefined;
1110
+ /**
1111
+ * <p>Inclusive lower bound on <code>eventTimestamp</code>: only events at or after this time are returned. Omit for no lower bound.</p> <p>If it's later than <code>eventTimestampBefore</code>, the request fails with <code>ValidationException</code>.</p>
1112
+ * @public
1113
+ */
1114
+ eventTimestampAfter?: Date | undefined;
1115
+ /**
1116
+ * <p>The order of the results by <code>eventTimestamp</code>: <code>ASC</code> or <code>DESC</code>. The default is <code>DESC</code>, most recent first.</p>
1117
+ * @public
1118
+ */
1119
+ sortOrder?: SortOrder | undefined;
1120
+ /**
1121
+ * <p>Returns only events whose metadata contains every one of these key-value pairs. Omit, or leave empty, for no metadata filter. The service applies the filter after it reads events, so a page can hold fewer than <code>maxResults</code> events, or none, and still return a <code>nextToken</code>. Keep paging until <code>nextToken</code> is absent.</p>
1122
+ * @public
1123
+ */
1124
+ metadataFilters?: Record<string, string> | undefined;
1125
+ /**
1126
+ * <p>The maximum number of events to return, from 1 to 100. The default is 20.</p>
1127
+ * @public
1128
+ */
1129
+ maxResults?: number | undefined;
1130
+ /**
1131
+ * <p>The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.</p>
1132
+ * @public
1133
+ */
1134
+ nextToken?: string | undefined;
1135
+ }
1136
+ /**
1137
+ * @public
1138
+ */
1139
+ export interface ListEventsOutput {
1140
+ /**
1141
+ * <p>The events, without their payloads. Call <code>GetEvent</code> for an event's payload.</p>
1142
+ * @public
1143
+ */
1144
+ events: EventSummary[] | undefined;
1145
+ /**
1146
+ * <p>The token for the next set of results. Absent when there are no more results.</p>
1147
+ * @public
1148
+ */
1149
+ nextToken?: string | undefined;
1150
+ }
1151
+ /**
1152
+ * <p>A memory type and, optionally, specific strategy names of that type. A space can hold several strategies of the same type, so the type and its names are given together.</p>
1153
+ * @public
1154
+ */
1155
+ export interface StrategySelector {
1156
+ /**
1157
+ * <p>The memory type to search or list.</p>
1158
+ * @public
1159
+ */
1160
+ memoryType: MemoryType | undefined;
1161
+ /**
1162
+ * <p>Specific strategy names of <code>memoryType</code>. Omit it to include every strategy of that type.</p>
1163
+ * @public
1164
+ */
1165
+ memoryStrategyNames?: string[] | undefined;
1166
+ }
1167
+ /**
1168
+ * @public
1169
+ */
1170
+ export interface ListMemoriesInput {
1171
+ /**
1172
+ * <p>The space whose memories to list.</p>
1173
+ * @public
1174
+ */
1175
+ spaceId: string | undefined;
1176
+ /**
1177
+ * <p>The strategies to list, as selectors. A selector without <code>memoryStrategyNames</code> lists every strategy of its type, and omitting <code>memoryStrategies</code> lists every strategy in the space. A name that is not a declared strategy of that type fails with <code>ValidationException</code>.</p>
1178
+ * @public
1179
+ */
1180
+ memoryStrategies?: StrategySelector[] | undefined;
1181
+ /**
1182
+ * <p>Lists only memories owned by one of these actors. Combined with <code>sessionIds</code> by AND: a memory must match both filters when both are given. Omit for no actor filter. An empty list fails validation. A memory stored without an actor never matches an actor filter.</p>
1183
+ * @public
1184
+ */
1185
+ actorIds?: string[] | undefined;
1186
+ /**
1187
+ * <p>Lists only memories from one of these sessions. Combined with <code>actorIds</code> by AND. Omit for no session filter. An empty list fails validation. A memory stored without a session never matches a session filter.</p>
1188
+ * @public
1189
+ */
1190
+ sessionIds?: string[] | undefined;
1191
+ /**
1192
+ * <p>The timestamp to sort by, as returned in <code>systemMetadata</code>: <code>CREATED_AT</code> (the default) or <code>UPDATED_AT</code>.</p>
1193
+ * @public
1194
+ */
1195
+ sortBy?: MemorySortField | undefined;
1196
+ /**
1197
+ * <p>The sort order: <code>ASC</code> or <code>DESC</code>. The default is <code>DESC</code>, most recent first.</p>
1198
+ * @public
1199
+ */
1200
+ sortOrder?: SortOrder | undefined;
1201
+ /**
1202
+ * <p>The maximum number of memories to return, from 1 to 100. The default is 20.</p>
1203
+ * @public
1204
+ */
1205
+ maxResults?: number | undefined;
1206
+ /**
1207
+ * <p>The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.</p>
1208
+ * @public
1209
+ */
1210
+ nextToken?: string | undefined;
1211
+ }
1212
+ /**
1213
+ * <p>A summary of a memory, as returned by <code>ListMemories</code>: its ID, type, provenance, and tags. It doesn't include <code>content</code>. Call <code>GetMemory</code> for the full memory.</p>
1214
+ * @public
1215
+ */
1216
+ export interface MemoryListSummary {
1217
+ /**
1218
+ * <p>The memory's ID, assigned by the service. IDs are opaque, can contain hyphens and underscores, and can be up to 512 characters long.</p>
1219
+ * @public
1220
+ */
1221
+ memoryId: string | undefined;
1222
+ /**
1223
+ * <p>The memory type.</p>
1224
+ * @public
1225
+ */
1226
+ memoryType: MemoryType | undefined;
1227
+ /**
1228
+ * <p>The name of the strategy the memory belongs to, for example <code>user-facts</code>: the strategy <code>memoryStrategies</code> selects on in <code>ListMemories</code>. Absent when the memory's strategy is no longer declared on the space, for example right after the strategy is deleted.</p>
1229
+ * @public
1230
+ */
1231
+ strategyName?: string | undefined;
1232
+ /**
1233
+ * <p>Provenance for the memory: the owning actor and session, and when it was created and last updated. Always present, with both timestamps.</p>
1234
+ * @public
1235
+ */
1236
+ systemMetadata: SystemMetadata | undefined;
1237
+ /**
1238
+ * <p>The memory's metadata tags. All values are strings.</p>
1239
+ * @public
1240
+ */
1241
+ metadata?: Record<string, string> | undefined;
1242
+ }
1243
+ /**
1244
+ * @public
1245
+ */
1246
+ export interface ListMemoriesOutput {
1247
+ /**
1248
+ * <p>The memories, in the requested order. Empty when there are none.</p>
1249
+ * @public
1250
+ */
1251
+ memories: MemoryListSummary[] | undefined;
1252
+ /**
1253
+ * <p>The token for the next set of results. Absent when there are no more results.</p>
1254
+ * @public
1255
+ */
1256
+ nextToken?: string | undefined;
1257
+ }
1258
+ /**
1259
+ * @public
1260
+ */
1261
+ export interface ListSpacesRequest {
1262
+ /**
1263
+ * <p>The maximum number of spaces to return, from 1 to 100. The default is 100.</p>
1264
+ * @public
1265
+ */
1266
+ maxResults?: number | undefined;
1267
+ /**
1268
+ * <p>The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.</p>
1269
+ * @public
1270
+ */
1271
+ nextToken?: string | undefined;
1272
+ }
1273
+ /**
1274
+ * <p>A summary of a space, as returned by <code>ListSpaces</code>.</p>
1275
+ * @public
1276
+ */
1277
+ export interface SpaceSummary {
1278
+ /**
1279
+ * <p>The ID of the space.</p>
1280
+ * @public
1281
+ */
1282
+ spaceId: string | undefined;
1283
+ /**
1284
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
1285
+ * @public
1286
+ */
1287
+ arn: string | undefined;
1288
+ /**
1289
+ * <p>The name of the space.</p>
1290
+ * @public
1291
+ */
1292
+ name: string | undefined;
1293
+ /**
1294
+ * <p>The status of the space.</p>
1295
+ * @public
1296
+ */
1297
+ status: SpaceStatus | undefined;
1298
+ /**
1299
+ * <p>When the space was created.</p>
1300
+ * @public
1301
+ */
1302
+ createdAt: Date | undefined;
1303
+ }
1304
+ /**
1305
+ * @public
1306
+ */
1307
+ export interface ListSpacesResponse {
1308
+ /**
1309
+ * <p>The spaces.</p>
1310
+ * @public
1311
+ */
1312
+ spaces: SpaceSummary[] | undefined;
1313
+ /**
1314
+ * <p>The token for the next set of results. Absent when there are no more results.</p>
1315
+ * @public
1316
+ */
1317
+ nextToken?: string | undefined;
1318
+ }
1319
+ /**
1320
+ * @public
1321
+ */
1322
+ export interface ListTagsForResourceRequest {
1323
+ /**
1324
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
1325
+ * @public
1326
+ */
1327
+ resourceArn: string | undefined;
1328
+ }
1329
+ /**
1330
+ * @public
1331
+ */
1332
+ export interface ListTagsForResourceResponse {
1333
+ /**
1334
+ * <p>The tags for the space.</p>
1335
+ * @public
1336
+ */
1337
+ tags?: Tag[] | undefined;
1338
+ }
1339
+ /**
1340
+ * <p>A <code>SearchMemories</code> result: a matching memory and its relevance score.</p>
1341
+ * @public
1342
+ */
1343
+ export interface MemorySearchSummary {
1344
+ /**
1345
+ * <p>The memory's ID, assigned by the service. Always present.</p>
1346
+ * @public
1347
+ */
1348
+ memoryId: string | undefined;
1349
+ /**
1350
+ * <p>The memory type of the result.</p>
1351
+ * @public
1352
+ */
1353
+ memoryType?: MemoryType | undefined;
1354
+ /**
1355
+ * <p>The name of the strategy the memory belongs to, for example <code>user-facts</code>: the strategy <code>memoryStrategies</code> selects on in <code>SearchMemories</code>. Absent when the memory's strategy is no longer declared on the space, for example right after the strategy is deleted.</p>
1356
+ * @public
1357
+ */
1358
+ strategyName?: string | undefined;
1359
+ /**
1360
+ * <p>The memory text.</p>
1361
+ * @public
1362
+ */
1363
+ content?: string | undefined;
1364
+ /**
1365
+ * <p>The relevance score of the result. A higher score is more relevant. Scores aren't normalized to a fixed range and can be greater than 1, so use them only to order results.</p>
1366
+ * @public
1367
+ */
1368
+ score?: number | undefined;
1369
+ /**
1370
+ * <p>Provenance for the memory: the actor and session that own it, and when it was created and last updated. It is the same block that <code>ListMemories</code>, <code>GetMemory</code>, and <code>SearchEvents</code> return.</p> <p>In a query, filter or sort on the timestamps as <code>system_metadata.created_at</code> and <code>system_metadata.updated_at</code>. Scope by owner with the top-level <code>actorId</code>, not in the query. Searching memories doesn't filter by session.</p> <p>Absent when the service has no provenance for the memory.</p>
1371
+ * @public
1372
+ */
1373
+ systemMetadata?: SystemMetadata | undefined;
1374
+ /**
1375
+ * <p>The memory's metadata tags. All values are strings. In a query, filter on a tag as <code>metadata.&lt;key&gt;</code>.</p>
1376
+ * @public
1377
+ */
1378
+ metadata?: Record<string, string> | undefined;
1379
+ /**
1380
+ * <p>The IDs of the events the memory was derived from, without duplicates. Use them with <code>GetEvent</code> or <code>BatchGetEvent</code>, or to search those events' content with <code>SearchEvents</code> by filtering on <code>event_ids</code> in the query. Absent for a memory created directly with <code>CreateMemory</code>. A memory can be derived from several events. The service sets this value.</p>
1381
+ * @public
1382
+ */
1383
+ sourceEventIds?: string[] | undefined;
1384
+ }
1385
+ /**
1386
+ * @public
1387
+ */
1388
+ export interface SearchEventsInput {
1389
+ /**
1390
+ * <p>The space whose events to search. Use <code>actorId</code> and <code>sessionIds</code> to narrow the search within it.</p>
1391
+ * @public
1392
+ */
1393
+ spaceId: string | undefined;
1394
+ /**
1395
+ * <p>The actor whose events to search (exact match). Required: every search covers exactly one actor, and an event stored without an actor is never returned. Narrow the search further with <code>sessionIds</code>, combined by AND. This is the only way to filter by actor: a query that references <code>system_metadata.actor_id</code> fails with <code>ValidationException</code> (reason <code>nonFilterableField</code>).</p>
1396
+ * @public
1397
+ */
1398
+ actorId: string | undefined;
1399
+ /**
1400
+ * <p>Returns only events from one of these sessions (exact match). Combined with <code>actorId</code> by AND. Omit for no session filter. An empty list fails validation. An event stored without a session never matches a session filter. This is the only way to filter by session: a query that references <code>system_metadata.session_id</code> fails with <code>ValidationException</code> (reason <code>nonFilterableField</code>).</p>
1401
+ * @public
1402
+ */
1403
+ sessionIds?: string[] | undefined;
1404
+ /**
1405
+ * <p>The query: a subset of the OpenSearch Query DSL (see <code>SearchQuery</code>), validated by the same rules as on <code>SearchMemories</code>. Query event text as <code>text</code> and embeddings as <code>vector</code>. A search covers both conversation turns and chunks of documents submitted as a <code>blob</code>. You can't use actor and session fields here. Use the top-level <code>actorId</code> and <code>sessionIds</code>.</p> <p>To search only the content of particular events, filter on <code>event_ids</code> with <code>term</code> or <code>terms</code>, for example with the <code>sourceEventIds</code> that a <code>SearchMemories</code> result returns. A <code>terms</code> clause on <code>event_ids</code> can list up to 10 event IDs. More IDs fail with <code>ValidationException</code> (reason <code>queryBodyTooLarge</code>). You can use <code>event_ids</code> only in <code>term</code>, <code>terms</code>, and <code>exists</code> queries.</p>
1406
+ * @public
1407
+ */
1408
+ query: __DocumentType | undefined;
1409
+ /**
1410
+ * <p>The sort order (see <code>SearchSort</code>). Omit to return the most relevant events first.</p>
1411
+ * @public
1412
+ */
1413
+ sort?: __DocumentType | undefined;
1414
+ /**
1415
+ * <p>The maximum number of events to return, from 1 to 100. The default is 20.</p>
1416
+ * @public
1417
+ */
1418
+ maxResults?: number | undefined;
1419
+ /**
1420
+ * <p>The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.</p>
1421
+ * @public
1422
+ */
1423
+ nextToken?: string | undefined;
1424
+ }
1425
+ /**
1426
+ * @public
1427
+ */
1428
+ export interface SearchEventsOutput {
1429
+ /**
1430
+ * <p>The matching event chunks, in the order <code>sort</code> requests, or most relevant first when it has none. Empty when nothing matches. Each result is the matching chunk of an event. Call <code>GetEvent</code> for the whole event.</p>
1431
+ * @public
1432
+ */
1433
+ events: EventSearchSummary[] | undefined;
1434
+ /**
1435
+ * <p>The token for the next set of results. Absent when there are no more results.</p>
1436
+ * @public
1437
+ */
1438
+ nextToken?: string | undefined;
1439
+ }
1440
+ /**
1441
+ * @public
1442
+ */
1443
+ export interface SearchMemoriesInput {
1444
+ /**
1445
+ * <p>The space to search. Use <code>actorId</code> to narrow the search within it.</p>
1446
+ * @public
1447
+ */
1448
+ spaceId: string | undefined;
1449
+ /**
1450
+ * <p>The strategies to search, as a list of selectors. Each selector names a memory type and, optionally, specific strategy names of that type. A space can hold several strategies of the same type. A selector without <code>memoryStrategyNames</code> searches every strategy of its type, and omitting <code>memoryStrategies</code> searches every strategy in the space. A name that is not a declared strategy of that type fails with <code>ValidationException</code>.</p>
1451
+ * @public
1452
+ */
1453
+ memoryStrategies?: StrategySelector[] | undefined;
1454
+ /**
1455
+ * <p>The actor whose memories to search (exact match). Required: every search covers exactly one actor, and a memory stored without an actor is never returned. This is the only way to filter by actor: a query that references <code>system_metadata.actor_id</code> fails with <code>ValidationException</code> (reason <code>nonFilterableField</code>).</p>
1456
+ * @public
1457
+ */
1458
+ actorId: string | undefined;
1459
+ /**
1460
+ * <p>The query: a subset of the OpenSearch Query DSL (see <code>SearchQuery</code>). You can't use the actor and session fields <code>system_metadata.actor_id</code> and <code>system_metadata.session_id</code> here. Use the top-level <code>actorId</code> to filter by actor. Searching memories doesn't filter by session.</p>
1461
+ * @public
1462
+ */
1463
+ query: __DocumentType | undefined;
1464
+ /**
1465
+ * <p>The sort order (see <code>SearchSort</code>). Omit to return the most relevant memories first.</p>
1466
+ * @public
1467
+ */
1468
+ sort?: __DocumentType | undefined;
1469
+ /**
1470
+ * <p>The maximum number of memories to return, from 1 to 100. The default is 20.</p>
1471
+ * @public
1472
+ */
1473
+ maxResults?: number | undefined;
1474
+ /**
1475
+ * <p>The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.</p>
1476
+ * @public
1477
+ */
1478
+ nextToken?: string | undefined;
1479
+ }
1480
+ /**
1481
+ * @public
1482
+ */
1483
+ export interface SearchMemoriesOutput {
1484
+ /**
1485
+ * <p>The matching memories, in the order <code>sort</code> requests, or most relevant first when it has none. Empty when nothing matches.</p>
1486
+ * @public
1487
+ */
1488
+ memories: MemorySearchSummary[] | undefined;
1489
+ /**
1490
+ * <p>The token for the next set of results. Absent when there are no more results.</p>
1491
+ * @public
1492
+ */
1493
+ nextToken?: string | undefined;
1494
+ }
1495
+ /**
1496
+ * @public
1497
+ */
1498
+ export interface UpdateMemoryInput {
1499
+ /**
1500
+ * <p>The ID of the space that owns the memory, for example <code>sp-02864597b164</code>.</p>
1501
+ * @public
1502
+ */
1503
+ spaceId: string | undefined;
1504
+ /**
1505
+ * <p>The ID of the memory to update.</p>
1506
+ * @public
1507
+ */
1508
+ memoryId: string | undefined;
1509
+ /**
1510
+ * <p>Replacement memory text. Supplying it re-embeds the memory. Omit to leave the text unchanged.</p>
1511
+ * @public
1512
+ */
1513
+ content?: string | undefined;
1514
+ /**
1515
+ * <p>The metadata tags to apply. By default this map replaces the stored metadata, and any key not present is removed. Set <code>metadataMode</code> to <code>MERGE</code> to keep the keys you don't supply. Limits apply to the resulting metadata, not to the request. Keys that begin with <code>x-amz-</code> and the key <code>documentS3Source</code> are reserved: a request that sets one fails with <code>ValidationException</code>.</p> <p>A space can use at most 50 distinct metadata keys across all of its events and memories. A request that would add a key beyond that fails with <code>ValidationException</code>. Reuse an existing key instead.</p>
1516
+ * @public
1517
+ */
1518
+ metadata?: Record<string, string> | undefined;
1519
+ /**
1520
+ * <p>How <code>metadata</code> combines with what is stored. The default is <code>REPLACE</code>.</p>
1521
+ * @public
1522
+ */
1523
+ metadataMode?: MetadataMode | undefined;
1524
+ /**
1525
+ * <p>The ID of the actor that the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
1526
+ * @public
1527
+ */
1528
+ actorId?: string | undefined;
1529
+ /**
1530
+ * <p>The name of the strategy that the memory must belong to. Omit it to skip this check. If it doesn't match the stored memory, the call fails with <code>ResourceNotFoundException</code>, as if the memory did not exist.</p>
1531
+ * @public
1532
+ */
1533
+ strategyName?: string | undefined;
1534
+ }
1535
+ /**
1536
+ * @public
1537
+ */
1538
+ export interface UpdateMemoryOutput {
1539
+ /**
1540
+ * <p>The updated memory, in the same shape that <code>GetMemory</code> returns.</p>
1541
+ * @public
1542
+ */
1543
+ memory: Memory | undefined;
1544
+ }
1545
+ /**
1546
+ * @public
1547
+ */
1548
+ export interface UpdateSpaceRequest {
1549
+ /**
1550
+ * <p>The ID of the space to update.</p>
1551
+ * @public
1552
+ */
1553
+ spaceId: string | undefined;
1554
+ /**
1555
+ * <p>The complete new list of memory strategies. The service removes strategies that aren't in the list from the space. Removing a strategy stops extraction for it but doesn't delete its memories: they're kept, until they expire if the space sets <code>memoryExpiryDays</code>, and they're available again if you later add a strategy with the same <code>type</code> and <code>name</code>. To delete them, use <code>DeleteMemory</code> before you remove the strategy, or delete the space.</p> <p>To keep a strategy, include it with the same <code>type</code> and <code>name</code> that <code>GetSpace</code> returns. For a kept strategy, any <code>configuration</code> member you omit keeps its current value. It doesn't return to the default, and you can't clear a member once it's set. Omit this field to leave the strategies unchanged. The list must name at least one strategy. You can't remove every strategy from a space with <code>UpdateSpace</code>.</p> <p>The serialized list can be at most 384 KiB.</p>
1556
+ * @public
1557
+ */
1558
+ memoryStrategies?: MemoryStrategy[] | undefined;
1559
+ /**
1560
+ * <p>How many days the space keeps each event, from 1 to 365. Omit it to leave the current value unchanged. Events already stored keep the expiry they were written with.</p>
1561
+ * @public
1562
+ */
1563
+ eventExpiryDays?: number | undefined;
1564
+ /**
1565
+ * <p>How many days the space keeps each memory, from 0 to 3650. 0 means memories never expire. Omit it to leave the current value unchanged. You can't clear the setting. To make memories written from then on never expire, send 0. <code>GetSpace</code> then returns 0.</p> <p>A change applies to memories written after it. Memories already stored keep the expiry they were written with. A memory the service rewrites later, such as a summary it keeps up to date, takes the setting in force at that rewrite. A change moves the space to <code>UPDATING</code>. Sending the value that the space has stored doesn't.</p>
1566
+ * @public
1567
+ */
1568
+ memoryExpiryDays?: number | undefined;
1569
+ /**
1570
+ * <p>The model that extracts and consolidates memories for every strategy in the space: <code>anthropic.claude-opus-5-5</code> or <code>anthropic.claude-haiku-5-5</code>. Omit it to leave the current value unchanged. Once set, it can't be cleared back to the service default.</p>
1571
+ * @public
1572
+ */
1573
+ extractionModelId?: string | undefined;
1574
+ }
1575
+ /**
1576
+ * @public
1577
+ */
1578
+ export interface UpdateSpaceResponse {
1579
+ /**
1580
+ * <p>The ID of the space.</p>
1581
+ * @public
1582
+ */
1583
+ spaceId: string | undefined;
1584
+ /**
1585
+ * <p>The status of the space: <code>UPDATING</code> when the change has to be applied to the space's strategies, retention, or extraction model. Otherwise, the space's current status.</p>
1586
+ * @public
1587
+ */
1588
+ status: SpaceStatus | undefined;
1589
+ }
1590
+ /**
1591
+ * @public
1592
+ */
1593
+ export interface TagResourceRequest {
1594
+ /**
1595
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
1596
+ * @public
1597
+ */
1598
+ resourceArn: string | undefined;
1599
+ /**
1600
+ * <p>The tags to add to the space.</p>
1601
+ * @public
1602
+ */
1603
+ tags: Tag[] | undefined;
1604
+ }
1605
+ /**
1606
+ * @public
1607
+ */
1608
+ export interface TagResourceResponse {
1609
+ }
1610
+ /**
1611
+ * @public
1612
+ */
1613
+ export interface UntagResourceRequest {
1614
+ /**
1615
+ * <p>The Amazon Resource Name (ARN) of the space.</p>
1616
+ * @public
1617
+ */
1618
+ resourceArn: string | undefined;
1619
+ /**
1620
+ * <p>The keys of the tags to remove from the space.</p>
1621
+ * @public
1622
+ */
1623
+ tagKeys: string[] | undefined;
1624
+ }
1625
+ /**
1626
+ * @public
1627
+ */
1628
+ export interface UntagResourceResponse {
1629
+ }