@stream-io/node-sdk 0.1.0

package/dist/src/gen/video/runtime.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Stream Video API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: v89.9.2
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare const BASE_PATH: string;
+export interface ConfigurationParameters {
+    basePath?: string;
+    fetchApi?: FetchAPI;
+    middleware?: Middleware[];
+    queryParamsStringify?: (params: HTTPQuery) => string;
+    username?: string;
+    password?: string;
+    apiKey?: string | ((name: string) => string);
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>);
+    headers?: HTTPHeaders;
+    credentials?: RequestCredentials;
+}
+export declare class Configuration {
+    private configuration;
+    constructor(configuration?: ConfigurationParameters);
+    set config(configuration: Configuration);
+    get basePath(): string;
+    get fetchApi(): FetchAPI | undefined;
+    get middleware(): Middleware[];
+    get queryParamsStringify(): (params: HTTPQuery) => string;
+    get username(): string | undefined;
+    get password(): string | undefined;
+    get apiKey(): ((name: string) => string) | undefined;
+    get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined;
+    get headers(): HTTPHeaders | undefined;
+    get credentials(): RequestCredentials | undefined;
+}
+export declare const DefaultConfig: Configuration;
+/**
+ * This is the base class for all generated API classes.
+ */
+export declare class BaseAPI {
+    protected configuration: Configuration;
+    private static readonly jsonRegex;
+    private middleware;
+    constructor(configuration?: Configuration);
+    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]): T;
+    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>): T;
+    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>): T;
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    protected isJsonMime(mime: string | null | undefined): boolean;
+    protected request(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction): Promise<Response>;
+    private createFetchParams;
+    private fetchApi;
+    /**
+     * Create a shallow clone of `this` by constructing a new instance
+     * and then shallow cloning data members.
+     */
+    private clone;
+}
+export declare class ResponseError extends Error {
+    response: Response;
+    name: "ResponseError";
+    constructor(response: Response, msg?: string);
+}
+export declare class FetchError extends Error {
+    cause: Error;
+    name: "FetchError";
+    constructor(cause: Error, msg?: string);
+}
+export declare class RequiredError extends Error {
+    field: string;
+    name: "RequiredError";
+    constructor(field: string, msg?: string);
+}
+export declare const COLLECTION_FORMATS: {
+    csv: string;
+    ssv: string;
+    tsv: string;
+    pipes: string;
+};
+export type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
+export type Json = any;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HTTPHeaders = {
+    [key: string]: string;
+};
+export type HTTPQuery = {
+    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery;
+};
+export type HTTPBody = Json | FormData | URLSearchParams;
+export type HTTPRequestInit = {
+    headers?: HTTPHeaders;
+    method: HTTPMethod;
+    credentials?: RequestCredentials;
+    body?: HTTPBody;
+};
+export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
+export type InitOverrideFunction = (requestContext: {
+    init: HTTPRequestInit;
+    context: RequestOpts;
+}) => Promise<RequestInit>;
+export interface FetchParams {
+    url: string;
+    init: RequestInit;
+}
+export interface RequestOpts {
+    path: string;
+    method: HTTPMethod;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+export declare function querystring(params: HTTPQuery, prefix?: string): string;
+export declare function canConsumeForm(consumes: Consume[]): boolean;
+export interface Consume {
+    contentType: string;
+}
+export interface RequestContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+}
+export interface ResponseContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    response: Response;
+}
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+export interface Middleware {
+    pre?(context: RequestContext): Promise<FetchParams | void>;
+    post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
+}
+export interface ApiResponse<T> {
+    raw: Response;
+    value(): Promise<T>;
+}
+export interface ResponseTransformer<T> {
+    (json: any): T;
+}
+export declare class JSONApiResponse<T> {
+    raw: Response;
+    private transformer;
+    constructor(raw: Response, transformer?: ResponseTransformer<T>);
+    value(): Promise<T>;
+}
+export declare class VoidApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<void>;
+}
+export declare class BlobApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<Blob>;
+}
+export declare class TextApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<string>;
+}

package/dist/src/types.d.ts

@@ -0,0 +1 @@
+export type OmitTypeId<T> = Omit<T, 'type' | 'id' | 'connection_id'>;

package/dist/src/utils/create-token.d.ts

@@ -0,0 +1,3 @@
+import { Secret, SignOptions } from "jsonwebtoken";
+export declare function JWTUserToken(apiSecret: Secret, userId: string, extraData?: {}, jwtOptions?: SignOptions): string;
+export declare function JWTServerToken(apiSecret: Secret, jwtOptions?: SignOptions): string;

package/index.ts

@@ -0,0 +1,7 @@
+export * from "./src/gen/chat/models";
+export * from './src/gen/video/models';
+export * from "./src/StreamClient";
+export * from "./src/StreamVideoClient";
+export * from "./src/StreamCall";
+export * from "./src/StreamChatClient";
+export * from "./src/StreamChannel";

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@stream-io/node-sdk",
+  "version": "0.1.0",
+  "description": "",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.es.js",
+  "types": "dist/index.d.ts",
+  "author": "https://getstream.io",
+  "license": "See license in LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GetStream/stream-node.git"
+  },
+  "scripts": {
+    "test": "vitest",
+    "start": "rollup -w -c",
+    "build": "rollup -c",
+    "generate:open-api": "./generate-openapi.sh protocol",
+    "generate:open-api:dev": "./generate-openapi.sh chat"
+  },
+  "files": [
+    "dist",
+    "src",
+    "index.ts",
+    "package.json",
+    "README.md",
+    "LICENSE",
+    ".readme-assets"
+  ],
+  "devDependencies": {
+    "@openapitools/openapi-generator-cli": "^2.7.0",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@rollup/plugin-typescript": "^11.1.4",
+    "@types/jsonwebtoken": "^9.0.3",
+    "@types/uuid": "^9.0.4",
+    "dotenv": "^16.3.1",
+    "rollup": "^3.29.3",
+    "typescript": "^5.2.2",
+    "uuid": "^9.0.1",
+    "vite": "^4.4.9",
+    "vitest": "^0.34.5",
+    "vitest-mock-extended": "^1.2.1"
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2"
+  }
+}

package/src/StreamCall.ts

@@ -0,0 +1,161 @@
+import { StreamClient } from "./StreamClient";
+import {
+  DefaultApi,
+  GetCallRequest,
+  VideoPinRequest,
+  VideoUnpinRequest,
+  VideoBlockUserRequest,
+  VideoGetOrCreateCallRequest,
+  VideoGoLiveRequest,
+  VideoMuteUsersRequest,
+  VideoUnblockUserRequest,
+  VideoUpdateCallRequest,
+  VideoUpdateCallMembersRequest,
+  VideoUpdateUserPermissionsRequest,
+  VideoQueryMembersRequest,
+} from "./gen/video";
+import { OmitTypeId } from "./types";
+
+export class StreamCall {
+  private readonly baseRequest: { type: string; id: string };
+  private readonly apiClient: DefaultApi;
+
+  constructor(
+    private streamClient: StreamClient,
+    private type: string,
+    private id: string
+  ) {
+    this.baseRequest = { id: this.id, type: this.type };
+    const configuration = this.streamClient.getConfiguration({
+      basePath:
+        this.streamClient.basePath || "https://video.stream-io-api.com/video",
+    });
+    this.apiClient = new DefaultApi(configuration);
+  }
+
+  accept = () => {
+    return this.apiClient.acceptCall(this.baseRequest);
+  };
+
+  blockUser = (videoBlockUserRequest: VideoBlockUserRequest) => {
+    return this.apiClient.blockUser({
+      ...this.baseRequest,
+      videoBlockUserRequest,
+    });
+  };
+
+  endCall = () => {
+    return this.apiClient.endCall({ ...this.baseRequest });
+  };
+
+  get = (request: OmitTypeId<GetCallRequest>) => {
+    return this.apiClient.getCall({ ...request, ...this.baseRequest });
+  };
+
+  getOrCreate = (videoGetOrCreateCallRequest?: VideoGetOrCreateCallRequest) => {
+    return this.apiClient.getOrCreateCall({
+      ...this.baseRequest,
+      videoGetOrCreateCallRequest: videoGetOrCreateCallRequest || {},
+    });
+  };
+
+  create = (getOrCreateCallRequest?: VideoGetOrCreateCallRequest) => {
+    return this.getOrCreate(getOrCreateCallRequest);
+  };
+
+  goLive = (videoGoLiveRequest?: VideoGoLiveRequest) => {
+    return this.apiClient.goLive({
+      ...this.baseRequest,
+      videoGoLiveRequest: videoGoLiveRequest || null,
+    });
+  };
+
+  listRecordings = () => {
+    return this.apiClient.listRecordings({
+      ...this.baseRequest,
+    });
+  };
+
+  muteUsers = (videoMuteUsersRequest: VideoMuteUsersRequest) => {
+    return this.apiClient.muteUsers({ ...this.baseRequest, videoMuteUsersRequest });
+  };
+
+  queryMembers = (request?: OmitTypeId<VideoQueryMembersRequest>) => {
+    return this.apiClient.queryMembers({
+      videoQueryMembersRequest: { ...(request || {}), ...this.baseRequest },
+    });
+  };
+
+  sendCustomEvent = (event: { [key: string]: any }) => {
+    return this.apiClient.sendEvent({
+      videoSendEventRequest: { custom: event },
+      ...this.baseRequest,
+    });
+  };
+
+  startHLSBroadcasting = () => {
+    return this.apiClient.startHLSBroadcasting({ ...this.baseRequest });
+  };
+
+  startRecording = () => {
+    return this.apiClient.startRecording({ ...this.baseRequest });
+  };
+
+  startTranscription = () => {
+    return this.apiClient.startTranscription({ ...this.baseRequest });
+  };
+
+  stopHLSBroadcasting = () => {
+    return this.apiClient.stopHLSBroadcasting({ ...this.baseRequest });
+  };
+
+  stopLive = () => {
+    return this.apiClient.stopLive({ ...this.baseRequest });
+  };
+
+  stopRecording = () => {
+    return this.apiClient.stopRecording({ ...this.baseRequest });
+  };
+
+  stopTranscription = () => {
+    return this.apiClient.stopTranscription({ ...this.baseRequest });
+  };
+
+  unblockUser = (videoUnblockUserRequest: VideoUnblockUserRequest) => {
+    return this.apiClient.unblockUser({
+      videoUnblockUserRequest,
+      ...this.baseRequest,
+    });
+  };
+
+  update = (videoUpdateCallRequest: VideoUpdateCallRequest) => {
+    return this.apiClient.updateCall({
+      videoUpdateCallRequest,
+      ...this.baseRequest,
+    });
+  };
+
+  updateCallMembers = (videoUpdateCallMembersRequest: VideoUpdateCallMembersRequest) => {
+    return this.apiClient.updateCallMembers({
+      videoUpdateCallMembersRequest,
+      ...this.baseRequest,
+    });
+  };
+
+  updateUserPermissions = (
+    videoUpdateUserPermissionsRequest: VideoUpdateUserPermissionsRequest
+  ) => {
+    return this.apiClient.updateUserPermissions({
+      videoUpdateUserPermissionsRequest,
+      ...this.baseRequest,
+    });
+  };
+
+  pinVideo = (videoPinRequest: VideoPinRequest) => {
+    return this.apiClient.videoPin({ videoPinRequest, ...this.baseRequest });
+  };
+
+  unpinVideo = (videoUnpinRequest: VideoUnpinRequest) => {
+    return this.apiClient.videoUnpin({ videoUnpinRequest, ...this.baseRequest });
+  };
+}

package/src/StreamChannel.ts

@@ -0,0 +1,165 @@
+import { StreamClient } from "./StreamClient";
+import { ChannelGetOrCreateRequest, ChannelsApi, DeleteChannelRequest, DeleteFileRequest, DeleteImageRequest, DeleteMessageRequest, DeleteReactionRequest, EventRequest, EventsApi, GetManyMessagesRequest, GetMessageRequest, GetOGRequest, GetReactionsRequest, GetRepliesRequest, HideChannelRequest, MarkReadRequest, MarkUnreadRequest, MessagesApi, MuteChannelRequest, QueryMembersRequest, SendMessageRequest, SendReactionRequest, ShowChannelRequest, TranslateMessageRequest, TruncateChannelRequest, UnmuteChannelRequest, UpdateChannelPartialRequest, UpdateChannelRequest, UpdateMessagePartialRequest, UpdateMessageRequest, UploadFileRequest, UploadImageRequest } from "./gen/chat";
+import { OmitTypeId } from "./types";
+
+export class StreamChannel {
+  private readonly channelsApi: ChannelsApi;
+  private readonly messagesApi: MessagesApi;
+  private readonly eventsApi: EventsApi;
+
+  constructor(
+    private streamClient: StreamClient,
+    public readonly type: string,
+    public id?: string
+  ) {
+    const configuration = this.streamClient.getConfiguration();
+    //@ts-expect-error typing problem
+    this.channelsApi = new ChannelsApi(configuration);
+    //@ts-expect-error typing problem
+    this.messagesApi = new MessagesApi(configuration);
+    //@ts-expect-error typing problem
+    this.eventsApi = new EventsApi(configuration);
+  }
+
+  get cid() {
+    return `${this.baseRequest.type}:${this.baseRequest.id}`
+  }
+
+  delete = (request?: OmitTypeId<DeleteChannelRequest>) => {
+    return this.channelsApi.deleteChannel({...this.baseRequest, ...(request || {})});
+  }
+
+  update = (updateChannelRequest: OmitTypeId<UpdateChannelRequest>) => {
+    return this.channelsApi.updateChannel({...this.baseRequest, updateChannelRequest});
+  }
+
+  updatePartial = (updateChannelPartialRequest: OmitTypeId<UpdateChannelPartialRequest>) => {
+    return this.channelsApi.updateChannelPartial({...this.baseRequest, updateChannelPartialRequest});
+  }
+
+  getOrCreate = async (channelGetOrCreateRequest?: ChannelGetOrCreateRequest) => {
+    if (this.id) {
+      return this.channelsApi.getOrCreateChannel({...this.baseRequest, channelGetOrCreateRequest: channelGetOrCreateRequest || {}});
+    } else {
+      throw new Error(`This operation isn't yet implemented`);
+      // if (!channelGetOrCreateRequest?.data?.members) {
+      //   throw new Error('You need to provide members to create a channel without ID');
+      // }
+      // const response = await this.channelsApi.getOrCreateChannelType1({type: this.type, channelGetOrCreateRequest});
+      // this.id = response.channel?.id;
+      // return response;
+    }
+  }
+
+  markRead = (markReadRequest: MarkReadRequest) => {
+    return this.channelsApi.markRead({...this.baseRequest, markReadRequest});
+  }
+
+  markUnread = (markUnreadRequest: MarkUnreadRequest) => {
+    return this.channelsApi.markUnread({...this.baseRequest, markUnreadRequest});
+  }
+
+  show = (showChannelRequest: ShowChannelRequest) => {
+    return this.channelsApi.showChannel({...this.baseRequest, showChannelRequest});
+  }
+
+  hide = (hideChannelRequest: HideChannelRequest) => {
+    return this.channelsApi.hideChannel({...this.baseRequest, hideChannelRequest});
+  }
+
+  truncate = (truncateChannelRequest: TruncateChannelRequest ) => {
+    return this.channelsApi.truncateChannel({...this.baseRequest, truncateChannelRequest});
+  }
+
+  queryMembers = (request: OmitTypeId<QueryMembersRequest>) => {
+    return this.channelsApi.queryMembers({payload: {...this.baseRequest, ...request}});
+  }
+
+  mute = (muteChannelRequest: Omit<MuteChannelRequest, 'channel_cids'>) => {
+    return this.channelsApi.muteChannel({muteChannelRequest: {...muteChannelRequest, channel_cids: [this.cid]}});
+  }
+
+  unmute = (unmuteChannelRequest: Omit<UnmuteChannelRequest, 'channel_cids' | 'channel_cid'>) => {
+    return this.channelsApi.unmuteChannel({unmuteChannelRequest: {...unmuteChannelRequest, channel_cid: this.cid, channel_cids: []}});
+  }
+
+  // TODO: there is probably an issue with the generated code here
+  // uploadFile = (options: Omit<OmitTypeId<UploadFileRequest>, 'file'>, file: Buffer) => {
+  //   return this.messagesApi.uploadFile({...options, ...this.baseRequest, file: file as any as string});
+  // }
+
+  // deleteFile = (request: OmitTypeId<DeleteFileRequest>) => {
+  //   return this.messagesApi.deleteFile({...request, ...this.baseRequest});
+  // }
+
+  // uploadImage = (request: OmitTypeId<UploadImageRequest>) => {
+  //   return this.messagesApi.uploadImage({...request, ...this.baseRequest});
+  // }
+
+  // deleteImage = (request: OmitTypeId<DeleteImageRequest>) => {
+  //   return this.messagesApi.deleteImage({...request, ...this.baseRequest});
+  // }
+
+  sendMessage = (sendMessageRequest: SendMessageRequest) => {
+    return this.messagesApi.sendMessage({...this.baseRequest, sendMessageRequest});
+  }
+
+  deleteMessage = (request: DeleteMessageRequest) => {
+    return this.messagesApi.deleteMessage(request);
+  }
+
+  updateMessage = (id: string, updateMessageRequest: UpdateMessageRequest) => {
+    return this.messagesApi.updateMessage({id, updateMessageRequest});
+  }
+
+  updateMessagePartial = (id: string, updateMessagePartialRequest: UpdateMessagePartialRequest) => {
+    return this.messagesApi.updateMessagePartial({id, updateMessagePartialRequest});
+  }
+
+  getMessage = (request: GetMessageRequest) => {
+    return this.messagesApi.getMessage(request);
+  }
+
+  getManyMessages = (request: OmitTypeId<GetManyMessagesRequest>) => {
+    return this.messagesApi.getManyMessages({...request, ...this.baseRequest});
+  }
+
+  translateMessage = (id: string, translateMessageRequest: TranslateMessageRequest) => {
+    return this.messagesApi.translateMessage({id, translateMessageRequest});
+  }
+
+  getMessagesAround = (request: GetRepliesRequest) => {
+    return this.messagesApi.getReplies(request);
+  }
+
+  getOpenGraphData = (request: GetOGRequest) => {
+    return this.messagesApi.getOG(request);
+  }
+
+  sendMessageReaction = (messageId: string, sendReactionRequest: SendReactionRequest) => {
+    return this.messagesApi.sendReaction({id: messageId, sendReactionRequest});
+  }
+
+  deleteMessageReaction = (messageId: string, request: Omit<DeleteReactionRequest, 'id'>) => {
+    return this.messagesApi.deleteReaction({...request, id: messageId});
+  }
+
+  getMessageReactions = (messageId: string, request?: Omit<GetReactionsRequest, 'id'>) => {
+    return this.messagesApi.getReactions({...(request || {}), id: messageId});
+  }
+
+  sendCustomEvent = (event: EventRequest) => {
+    return this.eventsApi.sendEvent({...this.baseRequest, sendEventRequest: {event}});
+  }
+
+  private get baseRequest() {
+    if (!this.id) {
+      throw new Error('You need to initialize the channel with `getOrCreate`');
+    }
+
+    return {
+      id: this.id,
+      type: this.type
+    }
+  }
+}

package/src/StreamChatClient.ts

@@ -0,0 +1,102 @@
+import { StreamChannel } from "./StreamChannel";
+import { StreamClient } from "./StreamClient";
+import { ChannelTypesApi, ChannelsApi, CreateBlockListRequest, CreateChannelTypeRequest, CreateCommandRequest, CustomCommandsApi, DeleteBlockListRequest, DeleteChannelTypeRequest, DeleteCommandRequest, ExportChannelsRequest, GetBlockListRequest, GetChannelTypeRequest, GetCommandRequest, GetExportChannelsStatusRequest, QueryChannelsRequest, SearchRequest, SettingsApi, UpdateBlockListRequest, UpdateChannelTypeRequest, UpdateCommandRequest } from "./gen/chat";
+
+export class StreamChatClient {
+  private settingsApi: SettingsApi;
+  private channelTypesApi: ChannelTypesApi;
+  private channelsApi: ChannelsApi;
+  private commandsApi: CustomCommandsApi;
+
+  constructor(private streamClient: StreamClient) {
+    const configuration = this.streamClient.getConfiguration();
+    //@ts-expect-error typing problem
+    this.settingsApi = new SettingsApi(configuration);
+    //@ts-expect-error typing problem
+    this.channelTypesApi = new ChannelTypesApi(configuration);
+    //@ts-expect-error typing problem
+    this.channelsApi = new ChannelsApi(configuration);
+    //@ts-expect-error typing problem
+    this.commandsApi = new CustomCommandsApi(configuration);
+  }
+
+  channel = (type: string, id?: string) => {
+    return new StreamChannel(this.streamClient, type, id);
+  }
+
+  createBlockList = (createBlockListRequest: CreateBlockListRequest) => {
+    return this.settingsApi.createBlockList({createBlockListRequest});
+  } 
+
+  listBlockLists = () => {
+    return this.settingsApi.listBlockLists();
+  }
+
+  getBlockList = (request: GetBlockListRequest) => {
+    return this.settingsApi.getBlockList(request);
+  }
+
+  updateBlockList = (name: string, updateBlockListRequest: UpdateBlockListRequest) => {
+    return this.settingsApi.updateBlockList({name, updateBlockListRequest});
+  }
+
+  deleteBlockList = (request: DeleteBlockListRequest) => {
+    return this.settingsApi.deleteBlockList(request);
+  }
+
+  createChannelType = (createChannelTypeRequest: CreateChannelTypeRequest) => {
+    return this.channelTypesApi.createChannelType({createChannelTypeRequest});
+  }
+
+  deleteChannelType = (request: DeleteChannelTypeRequest) => {
+    return this.channelTypesApi.deleteChannelType(request);
+  }
+
+  getChannelType = (request: GetChannelTypeRequest) => {
+    return this.channelTypesApi.getChannelType(request);
+  }
+
+  listChannelTypes = () => {
+    return this.channelTypesApi.listChannelTypes();
+  }
+
+  updateChannelType = (name: string, updateChannelTypeRequest: UpdateChannelTypeRequest) => {
+    return this.channelTypesApi.updateChannelType({name, updateChannelTypeRequest});
+  }
+
+  queryChannels = (queryChannelsRequest?: QueryChannelsRequest) => {
+    return this.channelsApi.queryChannels({queryChannelsRequest: queryChannelsRequest || null});
+  }
+
+  searchMessages = (payload?: SearchRequest) => {
+    return this.channelsApi.search({payload: payload});
+  }
+
+  exportChannels = (exportChannelsRequest?: ExportChannelsRequest) => {
+    return this.channelsApi.exportChannels({exportChannelsRequest: exportChannelsRequest || null});
+  }
+
+  getExportStatus = (request: GetExportChannelsStatusRequest) => {
+    return this.channelsApi.getExportChannelsStatus(request);
+  }
+
+  listCommands = () => {
+    return this.commandsApi.listCommands();
+  }
+
+  createCommand = (createCommandRequest: CreateCommandRequest) => {
+    return this.commandsApi.createCommand({createCommandRequest});
+  }
+
+  getCommand = (getCommandRequest: GetCommandRequest) => {
+    return this.commandsApi.getCommand(getCommandRequest);
+  }
+
+  updateCommand = (name: string, updateCommandRequest: UpdateCommandRequest) => {
+    return this.commandsApi.updateCommand({name, updateCommandRequest})
+  }
+
+  deleteCommand = (request: DeleteCommandRequest) => {
+    return this.commandsApi.deleteCommand(request);
+  }
+}