@amityco/ts-sdk 0.0.1-02f0fa3.0

package/dist/core/query/query.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Type guard to check and cast that a given async function is has the ".locally" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has a 'locally' twin
+ *
+ * @hidden
+ */
+export declare const isFetcher: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.FetcherFunc<Args, Returned>;
+/**
+ * Type guard to check and cast that a given async function is has the ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an 'optimistically' twin
+ *
+ * @hidden
+ */
+export declare const isMutator: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.MutatorFunc<Args, Returned>;
+/**
+ * Type guard to check and cast that a given async function is has
+ * the ".locally" or ".optimistically" property
+ *
+ * @param func any SDK APi function
+ * @returns success boolean if the function has an offline twin
+ *
+ * @hidden
+ */
+export declare const isOffline: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned>) => func is Amity.OfflineFunc<Args, Returned>;
+/**
+ * Type guard to check and cast that a given object has the "syncedAt" property
+ *
+ * @param model any object to check on
+ * @returns success boolean if the object has property "syncedAt"
+ *
+ * @hidden
+ */
+export declare const isSyncable: (model: any) => model is Amity.Syncable;
+/**
+ * Checks if a model is considered local (syncedAt === -1)
+ *
+ * @param model any syncable object to check
+ * @returns success boolean if the object is marked as local
+ *
+ * @hidden
+ */
+export declare const isLocal: (model?: any) => model is Amity.Syncable;
+/**
+ * Checks if a model is considered fresh
+ *
+ * @param model any syncable object to check
+ * @param lifeSpan the supposedly duration for which the object is considered synced
+ * @returns success boolean if the object is below the given lifespan
+ *
+ * @hidden
+ */
+export declare const isFresh: (model?: Amity.Syncable | undefined, lifeSpan?: number) => boolean;
+/**
+ * Checks if a model is considered synced
+ *
+ * @param model any syncable object to check
+ * @param lifeSpan the supposedly duration for which the object is considered synced
+ * @returns success boolean if the object is local or below the given lifespan
+ *
+ * @hidden
+ */
+export declare const isSynced: (model?: any, lifeSpan?: number) => boolean;
+/**
+ * ```js
+ * import { createQuery, getUser } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, 'foobar')
+ * ```
+ *
+ * Creates a wrapper for the API call you wish to call.
+ * This wrapper is necessary to create for optimistically calls
+ *
+ *
+ * @param fn A compatible API function from the ts sdk
+ * @param args The arguments to pass to the function passed as `fn`
+ * @returns A wrapper containing both the function and its future arguments
+ *
+ * @category Query
+ */
+export declare const createQuery: <Args extends any[], Returned extends unknown>(func: Amity.AsyncFunc<Args, Returned> | Amity.OfflineFunc<Args, Returned>, ...args: Args) => {
+    func: Amity.AsyncFunc<Args, Returned> | Amity.OfflineFunc<Args, Returned>;
+    args: Args;
+};
+/**
+ * ```js
+ * import { queryOptions } from '@amityco/ts-sdk'
+ * const options = queryOptions('no_fetch', lifeSpan)
+ * ```
+ *
+ * Creates a query options object based on the query policy passed
+ *
+ * @param policy The policy to apply to a query
+ * @returns A properly set query options object
+ *
+ * @category Query
+ */
+export declare const queryOptions: (policy: Amity.QueryPolicy, lifeSpan?: number) => Amity.QueryOptions;
+/**
+ * ```js
+ * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
+ * const query = createQuery(getUser, client, 'foobar')
+ * runQuery(query,  user => console.log(user))
+ * ```
+ *
+ * Calls an API function wrapped around a Amity.Query, and executes the callback whenever
+ * a value is available. The value can be picked either from the local cache and/or
+ * from the server afterwards depending on the query options passed
+ *
+ * @param query A query object wrapping the call to be made
+ * @param callback A function to execute when a value is available
+ * @param options the query options
+ *
+ * @category Query
+ */
+export declare const runQuery: <Args extends any[], Returned extends unknown>({ func, args }: Amity.Query<Args, Returned>, callback?: ((args: ({
+    data?: undefined;
+} & Amity.QueryMetadata) | Amity.QueryResult<Returned>) => void) | undefined, options?: Amity.QueryOptions) => void;
+//# sourceMappingURL=query.d.ts.map

package/dist/core/query/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/core/query/query.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,oIAIrB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,oIAIrB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,oIAE4D,CAAA;AAElF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,UAAW,GAAG,4BAEpC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,WAAY,GAAG,4BAElC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,kDAAsC,MAAM,YAE/D,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,WAAY,GAAG,aAAY,MAAM,YAErD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;;;CAGH,CAAA;AAGrB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,WACf,MAAM,WAAW,aAAY,MAAM,KAC1C,MAAM,YAOR,CAAA;AAoED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ;;2DAE2C,IAAI,yBACzD,MAAM,YAAY,SAwD5B,CAAA"}

package/dist/core/query/sorting.d.ts

@@ -0,0 +1,39 @@
+declare type SortingFunc<T = Object> = (a: T, b: T) => number;
+/**
+ * Alphabetic sorting of objects having a displayName
+ */
+export declare const sortByDisplayName: SortingFunc<{
+    displayName: string;
+}>;
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+export declare const sortByChannelSegment: SortingFunc<{
+    channelSegment: number;
+}>;
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+export declare const sortBySegmentNumber: SortingFunc<{
+    segmentNumber: number;
+}>;
+/**
+ * Sorting a collection by its oldest items
+ */
+export declare const sortByFirstCreated: SortingFunc<{
+    createdAt: Date | number | string;
+}>;
+/**
+ * Sorting a collection by its newest items
+ */
+export declare const sortByLastCreated: SortingFunc<{
+    createdAt: Date | number | string;
+}>;
+/**
+ * Sorting a collection by the items with most recent activity
+ */
+export declare const sortByLastActivity: SortingFunc<{
+    lastActivity: Date | number | string;
+}>;
+export {};
+//# sourceMappingURL=sorting.d.ts.map

package/dist/core/query/sorting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorting.d.ts","sourceRoot":"","sources":["../../../src/core/query/sorting.ts"],"names":[],"mappings":"AAIA,aAAK,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;AAErD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAKlE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAE/D,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAE7D,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC;IAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAEhC,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC;IAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAE/B,CAAA;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC;IAAE,YAAY,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAEnC,CAAA"}

package/dist/core/stores/index.d.ts

@@ -0,0 +1,3 @@
+export * from './memory';
+export * from './persistent';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/stores/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA"}

package/dist/core/stores/memory.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Minimal store implementation.
+ *
+ * Beware, the state is mutable! it is your responsibility
+ * handle the state's mutations correctly. We do so in
+ * order for users with mutable/observable stacks to be able
+ * to decorate the state with their favorite libraries.
+ *
+ * @param defaultValue the hydration state value of the store
+ * @returns A store instance with an "in memory" storage strategy
+ *
+ * @category Storage
+ * @hidden
+ */
+export declare const memoryStore: <T extends {}>(defaultValue?: Record<string, T>) => Amity.Store<T>;
+/**
+ * ```js
+ * import { memoryStores } from '@amityco/core/cache/store/volatile'
+ * const stores = imemoryStores('user', 'file')
+ * ```
+ *
+ * Builds a collection of in memory stores based on the available store names
+ *
+ * @param names collection of store names
+ * @returns a dictionary of { storeName: storeInstance } according to the given names
+ *
+ * @category Storage
+ */
+export declare const memoryStores: <T extends (keyof Amity.Model)[]>(...names: T) => Amity.StoreCollection<T>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/core/stores/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/core/stores/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,oEAsBvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,4EAOxB,CAAA"}

package/dist/core/stores/persistent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Persistent store implementation.
+ *
+ * @param persistentKey the name of the store in persistent storage
+ * @param defaultValue the hydration state value of the store
+ * @param debounceTime a delay to avoid spamming the persistent storage while writing,
+ * @returns A store instance with an "persistent" storage strategy
+ *
+ * @category Storage
+ * @hidden
+ */
+export declare const persistentStore: <T extends {}>(persistentKey: string, defaultValue?: Record<string, T>, debounceTime?: number) => Promise<Amity.Store<T>>;
+//# sourceMappingURL=persistent.d.ts.map

package/dist/core/stores/persistent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent.d.ts","sourceRoot":"","sources":["../../../src/core/stores/persistent.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,gCACX,MAAM,qFA4CtB,CAAA"}

package/dist/core/transports.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="socket.io-client" />
+/**
+ * Creates a pre-configured axios instance
+ *
+ * @param endpoint The ASC rest api server's URL
+ * @returns A pre-configured axios instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export declare const createHttpTransport: (endpoint?: string) => import("axios").AxiosInstance;
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The socket.io server's URL
+ * @returns A pre-configured (non-connected) socket.io client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export declare const createWebsocketTransport: (endpoint?: string) => SocketIOClient.Socket;
+/**
+ * Unwraps v3 server payload (for error handling and type extraction)
+ *
+ * @param response A typical "v3" response (related to backend's service strategy)
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @hidden
+ */
+export declare const unwrapPayload: <T>(response: Amity.Response<T>) => T;
+/**
+ * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
+ *
+ * @param client The current client for which to send the event with
+ * @param event The websocket event name
+ * @param data The event's payload
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @async
+ * @hidden
+ */
+export declare const synchronousWSCall: <T>(client: Amity.Client, event: string, data?: Object | undefined) => Promise<T | undefined>;
+//# sourceMappingURL=transports.d.ts.map

package/dist/core/transports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transports.d.ts","sourceRoot":"","sources":["../../src/core/transports.ts"],"names":[],"mappings":";AAgCA;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,cAAc,MAAM,kCA2BnD,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,cAAc,MAAM,0BAmBxD,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,uCAWzB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,cACpB,MAAM,MAAM,SACb,MAAM,sDAgBd,CAAA"}

package/dist/core/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare const uuid: () => string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/core/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../src/core/uuid.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,IAAI,cAA0C,CAAA"}

package/dist/feed/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './queryGlobalFeed';
+//# sourceMappingURL=index.d.ts.map

package/dist/feed/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feed/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/feed/api/queryGlobalFeed.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ **/
+export declare const queryGlobalFeed: (query?: {
+    dataTypes?: ("video" | "image" | "file")[] | undefined;
+    page?: Amity.Page | undefined;
+} | undefined) => Promise<{
+    data: Record<string, Amity.Post<any>>;
+    nextPage: Amity.Page | null;
+    prevPage: Amity.Page | null;
+}>;
+//# sourceMappingURL=queryGlobalFeed.d.ts.map

package/dist/feed/api/queryGlobalFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryGlobalFeed.d.ts","sourceRoot":"","sources":["../../../src/feed/api/queryGlobalFeed.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;IAaI;AACJ,eAAO,MAAM,eAAe;;;;;;;EA6B3B,CAAA"}

package/dist/file/api/createFile.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```js
+ * import { createFile } from '@amityco/ts-sdk'
+ * const created = await createFile(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+export declare const createFile: <T extends Amity.FileType = any>(formData: FormData, onProgress?: ((percent: number) => void) | undefined) => Promise<Amity.File<T>>;
+//# sourceMappingURL=createFile.d.ts.map

package/dist/file/api/createFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFile.d.ts","sourceRoot":"","sources":["../../../src/file/api/createFile.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,6CACX,QAAQ,0BACK,MAAM,KAAK,IAAI,wCA2BvC,CAAA"}

package/dist/file/api/deleteFile.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ```js
+ * import { deleteFile } from '@amityco/ts-sdk'
+ * const success = await deleteFile('foo')
+ * ```
+ *
+ * Deletes a {@link Amity.File}
+ *
+ * @param fileId The {@link Amity.File} ID to delete
+ * @return A success boolean if the {@link Amity.File} was deleted
+ *
+ * @category File API
+ * @async
+ */
+export declare const deleteFile: (fileId: Amity.File<any>['fileId']) => Promise<boolean>;
+//# sourceMappingURL=deleteFile.d.ts.map

package/dist/file/api/deleteFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteFile.d.ts","sourceRoot":"","sources":["../../../src/file/api/deleteFile.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,WACb,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,qBAelC,CAAA"}

package/dist/file/api/fileUrlWithSize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Allow to query a file url with a selected size
+ *
+ * @param fileUrl the file Url to decorate
+ * @param size one of the selected sizes
+ * @returns the computed url for the selected size
+ */
+export declare const fileUrlWithSize: (fileUrl: Amity.File['fileUrl'], size: 'small' | 'medium' | 'large' | 'full') => string;
+//# sourceMappingURL=fileUrlWithSize.d.ts.map

package/dist/file/api/fileUrlWithSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileUrlWithSize.d.ts","sourceRoot":"","sources":["../../../src/file/api/fileUrlWithSize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,YACjB,UAAU,CAAC,SAAS,CAAC,QACxB,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,WAG5C,CAAA"}

package/dist/file/api/getFile.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = await getFile('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object
+ *
+ * @param filelId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ * @async
+ */
+export declare const getFile: {
+    <T extends Amity.FileType = any>(fileId: Amity.File<any>['fileId']): Promise<Amity.FilePayload<T>>;
+    /**
+     * ```js
+     * import { getFile } from '@amityco/ts-sdk'
+     * const file = getFile.locally('foo')
+     * ```
+     *
+     * Fetches a {@link Amity.File} object from cache
+     *
+     * @param fileId the ID of the {@link Amity.File} to fetch
+     * @returns the associated {@link Amity.File} object
+     *
+     * @category File API
+     */
+    locally(fileId: Amity.File<any>['fileId']): Amity.File<any>;
+};
+//# sourceMappingURL=getFile.d.ts.map

package/dist/file/api/getFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFile.d.ts","sourceRoot":"","sources":["../../../src/file/api/getFile.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO;6CACV,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;IAkBnC;;;;;;;;;;;;OAYG;oBAEO,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;CAhBlC,CAAA"}

package/dist/file/api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getFile';
+export * from './createFile';
+export * from './deleteFile';
+export * from './fileUrlWithSize';
+//# sourceMappingURL=index.d.ts.map

package/dist/file/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/file/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA"}

package/dist/file/observers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './observeFile';
+//# sourceMappingURL=index.d.ts.map

package/dist/file/observers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/file/observers/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/file/observers/observeFile.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ```js
+ * import { observeFile } from '@amityco/ts-sdk'
+ *
+ * let file = {}
+ * const dispose = observeFile(fileId, updated => file = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.File}
+ *
+ * @param fileId the ID of the file to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the file
+ *
+ * @category File Observer
+ */
+export declare const observeFile: <Events extends ["onFetch"]>(fileId: string, callback: Amity.ObjectListener<{
+    data?: Amity.File<any> | undefined;
+} & Amity.QueryMetadata, Events>) => Amity.Unsubscriber;
+//# sourceMappingURL=observeFile.d.ts.map

package/dist/file/observers/observeFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observeFile.d.ts","sourceRoot":"","sources":["../../../src/file/observers/observeFile.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,uCACd,MAAM;;qCAEb,MAAM,YA+BR,CAAA"}