@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-c58e50d.0

package/dist/core/errors.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Generic ASC error
+ * @category Errors
+ */
+export declare class ASCError extends Error {
+    readonly code: Amity.ClientError;
+    readonly level: Amity.ErrorLevel;
+    readonly type: string;
+    readonly timestamp: number;
+    /**
+     * @param message A custom error message
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(message: string, code: Amity.ClientError, level: Amity.ErrorLevel);
+}
+/**
+ * API level error
+ * @category Errors
+ */
+export declare class ASCApiError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(message: string, code: Amity.ClientError, level: Amity.ErrorLevel);
+}
+/**
+ * Unexpected error
+ * @category Errors
+ */
+export declare class ASCUnknownError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(code?: Amity.ClientError, level?: Amity.ErrorLevel);
+}
+/**
+ * Network related error
+ * @category Errors
+ */
+export declare class ASCConnectionError extends ASCError {
+    /**
+     * @param message A custom error message
+     */
+    constructor(message?: string);
+}
+/**
+ * Input sanitization related error
+ * @category Errors
+ */
+export declare class ASCInvalidParameterError extends ASCError {
+    /**
+     * @param message A custom error message
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/events.d.ts

@@ -0,0 +1,33 @@
+/** @hidden */
+export declare const createEventEmitter: () => import("mitt").Emitter<Amity.Events>;
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+export declare const proxyWebsocketEvents: (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => void;
+/**
+ * Standardize the subscription of SSE through web sockets
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
+ *
+ * @category Transport
+ * @hidden
+ */
+export declare const createEventSubscriber: <T extends keyof Amity.Events>(client: Amity.Client, namespace: string, event: T, fn: Amity.Listener<Amity.Events[T]>) => Amity.Unsubscriber;
+/**
+ * Wrapper around dispatch event
+ *
+ * @hidden
+ */
+export declare const fireEvent: <T extends keyof Amity.Events>(event: T, payload: Amity.Events[T]) => void;
+//# sourceMappingURL=events.d.ts.map

package/dist/core/model/idResolvers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A resolver function is a function which, given a minimal version of a model T
+ * can compute a string which is capable of identifying the given model uniquely
+ * @hidden
+ */
+declare type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string;
+/**
+ * Retrieve the id resolver matching a domain name
+ *
+ * @param name the domain name for the resolve
+ * @returns an idResolver for the given domain name
+ */
+export declare const getResolver: <T extends keyof Amity.Model>(name: T) => Resolver<T>;
+/**
+ * A map of v3 response keys to a store name.
+ * @hidden
+ */
+export declare const storeInterests: Record<string, Amity.Domain>;
+export {};
+//# sourceMappingURL=idResolvers.d.ts.map

package/dist/core/model/idResolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idResolvers.d.ts","sourceRoot":"","sources":["../../../src/core/model/idResolvers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,aAAK,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAA;AAgC3E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,uDAEvB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAcvD,CAAA"}

package/dist/core/model/identifyModel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Finds the name of the store for a given unknown model
+ *
+ * @param model one of the {@link Amity.Model} to identify
+ * @returns the name of the corresponding store
+ */
+export declare const identifyModel: (model: Amity.Model[Amity.Domain]) => keyof Amity.Model | undefined;
+//# sourceMappingURL=identifyModel.d.ts.map

package/dist/core/model/identifyModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifyModel.d.ts","sourceRoot":"","sources":["../../../src/core/model/identifyModel.ts"],"names":[],"mappings":"AAsBA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,KAAK,CAAC,MAAM,MAAM,CAAC,kCAG7D,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from './identifyModel';
+export * from './idResolvers';
+export * from './toRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/model/toRecord.d.ts

@@ -0,0 +1,10 @@
+/**
+ * converts an array looking collection to an object collection, grouped by localId
+ *
+ * @param array array of {@link Amity.Syncable}
+ * @returns array converted to object, grouped by localId
+ *
+ * @hidden
+ */
+export declare const toRecord: <T extends Amity.Syncable>(array: T[]) => Record<string, T>;
+//# sourceMappingURL=toRecord.d.ts.map

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

@@ -0,0 +1,23 @@
+/**
+ * Set the model's syncedAt property and localId
+ *
+ * @param model the model to decorate
+ * @param timestamp the given timestamp
+ */
+export declare const decoratePayload: (payload: Record<string, object[]>, timestamp?: number, keyMapping?: Record<string, Amity.Domain>) => void;
+/**
+ * Set the model's syncedAt property and localId
+ *
+ * @param model the model to decorate
+ * @param timestamp the given timestamp
+ */
+export declare const decorateModels: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(models: T[], timestamp?: number, type?: keyof Amity.Model | undefined) => void;
+/**
+ * Set the model's syncedAt property and localId
+ *
+ * @param model the model to decorate
+ * @param syncedAt the given timestamp
+ * @param type An opportunity to manually pass the type. If undefined, it will be smartly computed
+ */
+export declare const decorateModel: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(model: T, timestamp?: number, type?: keyof Amity.Model | undefined) => void;
+//# sourceMappingURL=decorate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorate.d.ts","sourceRoot":"","sources":["../../../src/core/query/decorate.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YACjB,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,cACtB,MAAM,eACL,OAAO,MAAM,EAAE,MAAM,MAAM,CAAC,SAQzC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,iQAEd,MAAM,+CAIlB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,8PAEb,MAAM,+CAWlB,CAAA"}

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

@@ -0,0 +1,12 @@
+/**
+ * Filter a given collection with strict equality against a param
+ *
+ * @param collection the collection to filter
+ * @param key the key of the collection's items to challenge
+ * @param value the expected value
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export declare const filterByPropEquality: <T = {}>(collection: T[], key: keyof T, value: any) => T[];
+//# sourceMappingURL=filtering.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './query';
+export * from './decorate';
+export * from './filtering';
+export * from './sorting';
+export * from './paging';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
+ *
+ * @param json any json object as extracted from the backend
+ * @returns success boolean if the token has either "skip" or "limit" props
+ *
+ * @hidden
+ */
+export declare const isSkipLimit: (json: Object) => json is Amity.SkipLimitPagination;
+/**
+ * Type guard to find if the a given decoded backend token uses "after/before" pagination style
+ *
+ * @param json any json object as extracted from the backend
+ * @returns success boolean if the token has either "after" or "before" props
+ *
+ * @hidden
+ */
+export declare const isAfterBefore: (json: Object) => json is Amity.AfterBeforePagination;
+/**
+ * Type guard to find if the a given object is wrapped around Amity.Paged<>
+ *
+ * @param payload any object as passed from query functions
+ * @returns success boolean if the object is an array shaped as [Record<string, Amity.Syncable>, Amity.Pages]
+ *
+ * @hidden
+ */
+export declare const isPaged: (payload: any) => payload is Amity.Paged<any>;
+/**
+ * Converts a paging object into a b64 string token
+ *
+ * @param paging the sdk-friendly paging object
+ * @param style the style of token to produce
+ * @returns a backend's b64 encoded token
+ *
+ * @hidden
+ */
+export declare const toToken: (paging: Amity.Page | undefined, style: 'skiplimit' | 'afterbefore') => Amity.Token | undefined;
+/**
+ * Converts a b64 string token into a paging object
+ *
+ * @param token the backend's b64 encoded token
+ * @returns a sdk-friendly paging object
+ *
+ * @hidden
+ */
+export declare const toPage: (token?: string | undefined) => Amity.Page | null;
+/**
+ * Slices a collection according to its paging
+ *
+ * @param type the type of collection (for unique id identification with after/before)
+ * @param collection the collection to slice
+ * @param paging the paging object
+ * @returns the sliced collection according to the paging definition
+ *
+ * @hidden
+ */
+export declare const sliceByPaging: <K extends keyof Amity.Model, T extends Amity.Model[K]>(type: K, collection: T[], page?: Amity.Page | undefined) => T[] | undefined;
+//# sourceMappingURL=paging.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../../src/core/query/paging.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,sCAEvC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,SAAU,MAAM,wCAEzC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,YAAa,GAAG,gCAMnC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,WACV,MAAM,IAAI,GAAG,SAAS,SACvB,WAAW,GAAG,aAAa,KAEjC,MAAM,KAAK,GAAG,SAuChB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,kCAA0B,MAAM,IAAI,GAAG,IA0BzD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,qIAsBzB,CAAA"}

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/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/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/feed/api/index.d.ts

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

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/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/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"}