@huaweicloud/huaweicloud-sdk-cloudrtc 3.1.43

package/v2/CloudRTCRegion.d.ts

@@ -0,0 +1,5 @@
+export declare class CloudRTCRegion {
+    static CN_NORTH_4: any;
+    private static REGION_MAP;
+    static valueOf(regionId: string): any;
+}

package/v2/CloudRTCRegion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudRTCRegion = void 0;
+var region_1 = require("@huaweicloud/huaweicloud-sdk-core/region/region");
+var CloudRTCRegion = exports.CloudRTCRegion = /** @class */ (function () {
+    function CloudRTCRegion() {
+    }
+    CloudRTCRegion.valueOf = function (regionId) {
+        if (!regionId) {
+            throw new Error("Unexpected empty parameter: regionId.");
+        }
+        var result = this.REGION_MAP[regionId];
+        if (result) {
+            return result;
+        }
+        throw new Error("Unexpected regionId: ".concat(regionId, "."));
+    };
+    CloudRTCRegion.CN_NORTH_4 = new region_1.Region("cn-north-4", ["https://rtc-api.myhuaweicloud.com"]);
+    CloudRTCRegion.REGION_MAP = {
+        "cn-north-4": CloudRTCRegion.CN_NORTH_4
+    };
+    return CloudRTCRegion;
+}());

package/v2/model/App.d.ts

@@ -0,0 +1,46 @@
+import { AppAuth } from './AppAuth';
+import { AppAutoRecordMode } from './AppAutoRecordMode';
+import { AppCallbacks } from './AppCallbacks';
+import { AppState } from './AppState';
+export declare class App {
+    private 'app_name'?;
+    private 'app_id'?;
+    state?: AppState;
+    scope?: AppScopeEnum;
+    private 'tenant_name'?;
+    domain?: string;
+    private 'create_time'?;
+    authentication?: AppAuth;
+    callbacks?: AppCallbacks;
+    private 'auto_record_mode'?;
+    constructor();
+    withAppName(appName: string): App;
+    set appName(appName: string | undefined);
+    get appName(): string | undefined;
+    withAppId(appId: string): App;
+    set appId(appId: string | undefined);
+    get appId(): string | undefined;
+    withState(state: AppState): App;
+    withScope(scope: AppScopeEnum): App;
+    withTenantName(tenantName: string): App;
+    set tenantName(tenantName: string | undefined);
+    get tenantName(): string | undefined;
+    withDomain(domain: string): App;
+    withCreateTime(createTime: string): App;
+    set createTime(createTime: string | undefined);
+    get createTime(): string | undefined;
+    withAuthentication(authentication: AppAuth): App;
+    withCallbacks(callbacks: AppCallbacks): App;
+    withAutoRecordMode(autoRecordMode: AppAutoRecordMode): App;
+    set autoRecordMode(autoRecordMode: AppAutoRecordMode | undefined);
+    get autoRecordMode(): AppAutoRecordMode | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum AppScopeEnum {
+    DOMESTIC = "DOMESTIC",
+    OVERSEA = "OVERSEA",
+    GLOBAL = "GLOBAL"
+}

package/v2/model/App.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppScopeEnum = exports.App = void 0;
+var App = /** @class */ (function () {
+    function App() {
+    }
+    App.prototype.withAppName = function (appName) {
+        this['app_name'] = appName;
+        return this;
+    };
+    Object.defineProperty(App.prototype, "appName", {
+        get: function () {
+            return this['app_name'];
+        },
+        set: function (appName) {
+            this['app_name'] = appName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.withAppId = function (appId) {
+        this['app_id'] = appId;
+        return this;
+    };
+    Object.defineProperty(App.prototype, "appId", {
+        get: function () {
+            return this['app_id'];
+        },
+        set: function (appId) {
+            this['app_id'] = appId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.withState = function (state) {
+        this['state'] = state;
+        return this;
+    };
+    App.prototype.withScope = function (scope) {
+        this['scope'] = scope;
+        return this;
+    };
+    App.prototype.withTenantName = function (tenantName) {
+        this['tenant_name'] = tenantName;
+        return this;
+    };
+    Object.defineProperty(App.prototype, "tenantName", {
+        get: function () {
+            return this['tenant_name'];
+        },
+        set: function (tenantName) {
+            this['tenant_name'] = tenantName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.withDomain = function (domain) {
+        this['domain'] = domain;
+        return this;
+    };
+    App.prototype.withCreateTime = function (createTime) {
+        this['create_time'] = createTime;
+        return this;
+    };
+    Object.defineProperty(App.prototype, "createTime", {
+        get: function () {
+            return this['create_time'];
+        },
+        set: function (createTime) {
+            this['create_time'] = createTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.withAuthentication = function (authentication) {
+        this['authentication'] = authentication;
+        return this;
+    };
+    App.prototype.withCallbacks = function (callbacks) {
+        this['callbacks'] = callbacks;
+        return this;
+    };
+    App.prototype.withAutoRecordMode = function (autoRecordMode) {
+        this['auto_record_mode'] = autoRecordMode;
+        return this;
+    };
+    Object.defineProperty(App.prototype, "autoRecordMode", {
+        get: function () {
+            return this['auto_record_mode'];
+        },
+        set: function (autoRecordMode) {
+            this['auto_record_mode'] = autoRecordMode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return App;
+}());
+exports.App = App;
+/**
+    * @export
+    * @enum {string}
+    */
+var AppScopeEnum;
+(function (AppScopeEnum) {
+    AppScopeEnum["DOMESTIC"] = "DOMESTIC";
+    AppScopeEnum["OVERSEA"] = "OVERSEA";
+    AppScopeEnum["GLOBAL"] = "GLOBAL";
+})(AppScopeEnum || (exports.AppScopeEnum = AppScopeEnum = {}));

package/v2/model/AppAuth.d.ts

@@ -0,0 +1,15 @@
+export declare class AppAuth {
+    enable?: boolean;
+    expire?: number;
+    private 'app_key'?;
+    private 'update_time'?;
+    constructor();
+    withEnable(enable: boolean): AppAuth;
+    withExpire(expire: number): AppAuth;
+    withAppKey(appKey: string): AppAuth;
+    set appKey(appKey: string | undefined);
+    get appKey(): string | undefined;
+    withUpdateTime(updateTime: string): AppAuth;
+    set updateTime(updateTime: string | undefined);
+    get updateTime(): string | undefined;
+}

package/v2/model/AppAuth.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAuth = void 0;
+var AppAuth = /** @class */ (function () {
+    function AppAuth() {
+    }
+    AppAuth.prototype.withEnable = function (enable) {
+        this['enable'] = enable;
+        return this;
+    };
+    AppAuth.prototype.withExpire = function (expire) {
+        this['expire'] = expire;
+        return this;
+    };
+    AppAuth.prototype.withAppKey = function (appKey) {
+        this['app_key'] = appKey;
+        return this;
+    };
+    Object.defineProperty(AppAuth.prototype, "appKey", {
+        get: function () {
+            return this['app_key'];
+        },
+        set: function (appKey) {
+            this['app_key'] = appKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AppAuth.prototype.withUpdateTime = function (updateTime) {
+        this['update_time'] = updateTime;
+        return this;
+    };
+    Object.defineProperty(AppAuth.prototype, "updateTime", {
+        get: function () {
+            return this['update_time'];
+        },
+        set: function (updateTime) {
+            this['update_time'] = updateTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppAuth;
+}());
+exports.AppAuth = AppAuth;

package/v2/model/AppAuthReq.d.ts

@@ -0,0 +1,7 @@
+export declare class AppAuthReq {
+    enable: boolean;
+    expire?: number;
+    constructor(enable?: any);
+    withEnable(enable: boolean): AppAuthReq;
+    withExpire(expire: number): AppAuthReq;
+}

package/v2/model/AppAuthReq.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAuthReq = void 0;
+var AppAuthReq = /** @class */ (function () {
+    function AppAuthReq(enable) {
+        this['enable'] = enable;
+    }
+    AppAuthReq.prototype.withEnable = function (enable) {
+        this['enable'] = enable;
+        return this;
+    };
+    AppAuthReq.prototype.withExpire = function (expire) {
+        this['expire'] = expire;
+        return this;
+    };
+    return AppAuthReq;
+}());
+exports.AppAuthReq = AppAuthReq;

package/v2/model/AppAutoRecordMode.d.ts

@@ -0,0 +1,21 @@
+export declare class AppAutoRecordMode {
+    mode: AppAutoRecordModeModeEnum;
+    private 'record_rule_id'?;
+    private 'update_time'?;
+    constructor(mode?: any);
+    withMode(mode: AppAutoRecordModeModeEnum): AppAutoRecordMode;
+    withRecordRuleId(recordRuleId: string): AppAutoRecordMode;
+    set recordRuleId(recordRuleId: string | undefined);
+    get recordRuleId(): string | undefined;
+    withUpdateTime(updateTime: string): AppAutoRecordMode;
+    set updateTime(updateTime: string | undefined);
+    get updateTime(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum AppAutoRecordModeModeEnum {
+    AUTO_RECORD_OFF = "AUTO_RECORD_OFF",
+    AUTO_INDIVIDUAL_RECORD = "AUTO_INDIVIDUAL_RECORD"
+}

package/v2/model/AppAutoRecordMode.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAutoRecordModeModeEnum = exports.AppAutoRecordMode = void 0;
+var AppAutoRecordMode = /** @class */ (function () {
+    function AppAutoRecordMode(mode) {
+        this['mode'] = mode;
+    }
+    AppAutoRecordMode.prototype.withMode = function (mode) {
+        this['mode'] = mode;
+        return this;
+    };
+    AppAutoRecordMode.prototype.withRecordRuleId = function (recordRuleId) {
+        this['record_rule_id'] = recordRuleId;
+        return this;
+    };
+    Object.defineProperty(AppAutoRecordMode.prototype, "recordRuleId", {
+        get: function () {
+            return this['record_rule_id'];
+        },
+        set: function (recordRuleId) {
+            this['record_rule_id'] = recordRuleId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AppAutoRecordMode.prototype.withUpdateTime = function (updateTime) {
+        this['update_time'] = updateTime;
+        return this;
+    };
+    Object.defineProperty(AppAutoRecordMode.prototype, "updateTime", {
+        get: function () {
+            return this['update_time'];
+        },
+        set: function (updateTime) {
+            this['update_time'] = updateTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppAutoRecordMode;
+}());
+exports.AppAutoRecordMode = AppAutoRecordMode;
+/**
+    * @export
+    * @enum {string}
+    */
+var AppAutoRecordModeModeEnum;
+(function (AppAutoRecordModeModeEnum) {
+    AppAutoRecordModeModeEnum["AUTO_RECORD_OFF"] = "AUTO_RECORD_OFF";
+    AppAutoRecordModeModeEnum["AUTO_INDIVIDUAL_RECORD"] = "AUTO_INDIVIDUAL_RECORD";
+})(AppAutoRecordModeModeEnum || (exports.AppAutoRecordModeModeEnum = AppAutoRecordModeModeEnum = {}));

package/v2/model/AppCallbackUrl.d.ts

@@ -0,0 +1,25 @@
+export declare class AppCallbackUrl {
+    url?: string;
+    private 'auth_key'?;
+    private 'notify_event_subscription'?;
+    private 'update_time'?;
+    constructor();
+    withUrl(url: string): AppCallbackUrl;
+    withAuthKey(authKey: string): AppCallbackUrl;
+    set authKey(authKey: string | undefined);
+    get authKey(): string | undefined;
+    withNotifyEventSubscription(notifyEventSubscription: Array<AppCallbackUrlNotifyEventSubscriptionEnum>): AppCallbackUrl;
+    set notifyEventSubscription(notifyEventSubscription: Array<AppCallbackUrlNotifyEventSubscriptionEnum> | undefined);
+    get notifyEventSubscription(): Array<AppCallbackUrlNotifyEventSubscriptionEnum> | undefined;
+    withUpdateTime(updateTime: string): AppCallbackUrl;
+    set updateTime(updateTime: string | undefined);
+    get updateTime(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum AppCallbackUrlNotifyEventSubscriptionEnum {
+    RECORD_NEW_FILE_START = "RECORD_NEW_FILE_START",
+    RECORD_FILE_COMPLETE = "RECORD_FILE_COMPLETE"
+}

package/v2/model/AppCallbackUrl.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppCallbackUrlNotifyEventSubscriptionEnum = exports.AppCallbackUrl = void 0;
+var AppCallbackUrl = /** @class */ (function () {
+    function AppCallbackUrl() {
+    }
+    AppCallbackUrl.prototype.withUrl = function (url) {
+        this['url'] = url;
+        return this;
+    };
+    AppCallbackUrl.prototype.withAuthKey = function (authKey) {
+        this['auth_key'] = authKey;
+        return this;
+    };
+    Object.defineProperty(AppCallbackUrl.prototype, "authKey", {
+        get: function () {
+            return this['auth_key'];
+        },
+        set: function (authKey) {
+            this['auth_key'] = authKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AppCallbackUrl.prototype.withNotifyEventSubscription = function (notifyEventSubscription) {
+        this['notify_event_subscription'] = notifyEventSubscription;
+        return this;
+    };
+    Object.defineProperty(AppCallbackUrl.prototype, "notifyEventSubscription", {
+        get: function () {
+            return this['notify_event_subscription'];
+        },
+        set: function (notifyEventSubscription) {
+            this['notify_event_subscription'] = notifyEventSubscription;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AppCallbackUrl.prototype.withUpdateTime = function (updateTime) {
+        this['update_time'] = updateTime;
+        return this;
+    };
+    Object.defineProperty(AppCallbackUrl.prototype, "updateTime", {
+        get: function () {
+            return this['update_time'];
+        },
+        set: function (updateTime) {
+            this['update_time'] = updateTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppCallbackUrl;
+}());
+exports.AppCallbackUrl = AppCallbackUrl;
+/**
+    * @export
+    * @enum {string}
+    */
+var AppCallbackUrlNotifyEventSubscriptionEnum;
+(function (AppCallbackUrlNotifyEventSubscriptionEnum) {
+    AppCallbackUrlNotifyEventSubscriptionEnum["RECORD_NEW_FILE_START"] = "RECORD_NEW_FILE_START";
+    AppCallbackUrlNotifyEventSubscriptionEnum["RECORD_FILE_COMPLETE"] = "RECORD_FILE_COMPLETE";
+})(AppCallbackUrlNotifyEventSubscriptionEnum || (exports.AppCallbackUrlNotifyEventSubscriptionEnum = AppCallbackUrlNotifyEventSubscriptionEnum = {}));

package/v2/model/AppCallbackUrlReq.d.ts

@@ -0,0 +1,9 @@
+export declare class AppCallbackUrlReq {
+    url: string;
+    private 'auth_key'?;
+    constructor(url?: any);
+    withUrl(url: string): AppCallbackUrlReq;
+    withAuthKey(authKey: string): AppCallbackUrlReq;
+    set authKey(authKey: string | undefined);
+    get authKey(): string | undefined;
+}

package/v2/model/AppCallbackUrlReq.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppCallbackUrlReq = void 0;
+var AppCallbackUrlReq = /** @class */ (function () {
+    function AppCallbackUrlReq(url) {
+        this['url'] = url;
+    }
+    AppCallbackUrlReq.prototype.withUrl = function (url) {
+        this['url'] = url;
+        return this;
+    };
+    AppCallbackUrlReq.prototype.withAuthKey = function (authKey) {
+        this['auth_key'] = authKey;
+        return this;
+    };
+    Object.defineProperty(AppCallbackUrlReq.prototype, "authKey", {
+        get: function () {
+            return this['auth_key'];
+        },
+        set: function (authKey) {
+            this['auth_key'] = authKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppCallbackUrlReq;
+}());
+exports.AppCallbackUrlReq = AppCallbackUrlReq;

package/v2/model/AppCallbacks.d.ts

@@ -0,0 +1,12 @@
+import { AppCallbackUrl } from './AppCallbackUrl';
+export declare class AppCallbacks {
+    private 'push_callback'?;
+    private 'record_callback'?;
+    constructor();
+    withPushCallback(pushCallback: AppCallbackUrl): AppCallbacks;
+    set pushCallback(pushCallback: AppCallbackUrl | undefined);
+    get pushCallback(): AppCallbackUrl | undefined;
+    withRecordCallback(recordCallback: AppCallbackUrl): AppCallbacks;
+    set recordCallback(recordCallback: AppCallbackUrl | undefined);
+    get recordCallback(): AppCallbackUrl | undefined;
+}

package/v2/model/AppCallbacks.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppCallbacks = void 0;
+var AppCallbacks = /** @class */ (function () {
+    function AppCallbacks() {
+    }
+    AppCallbacks.prototype.withPushCallback = function (pushCallback) {
+        this['push_callback'] = pushCallback;
+        return this;
+    };
+    Object.defineProperty(AppCallbacks.prototype, "pushCallback", {
+        get: function () {
+            return this['push_callback'];
+        },
+        set: function (pushCallback) {
+            this['push_callback'] = pushCallback;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AppCallbacks.prototype.withRecordCallback = function (recordCallback) {
+        this['record_callback'] = recordCallback;
+        return this;
+    };
+    Object.defineProperty(AppCallbacks.prototype, "recordCallback", {
+        get: function () {
+            return this['record_callback'];
+        },
+        set: function (recordCallback) {
+            this['record_callback'] = recordCallback;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppCallbacks;
+}());
+exports.AppCallbacks = AppCallbacks;

package/v2/model/AppReq.d.ts

@@ -0,0 +1,7 @@
+export declare class AppReq {
+    private 'app_name';
+    constructor(appName?: any);
+    withAppName(appName: string): AppReq;
+    set appName(appName: string | undefined);
+    get appName(): string | undefined;
+}

package/v2/model/AppReq.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppReq = void 0;
+var AppReq = /** @class */ (function () {
+    function AppReq(appName) {
+        this['app_name'] = appName;
+    }
+    AppReq.prototype.withAppName = function (appName) {
+        this['app_name'] = appName;
+        return this;
+    };
+    Object.defineProperty(AppReq.prototype, "appName", {
+        get: function () {
+            return this['app_name'];
+        },
+        set: function (appName) {
+            this['app_name'] = appName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppReq;
+}());
+exports.AppReq = AppReq;

package/v2/model/AppState.d.ts

@@ -0,0 +1,19 @@
+export declare class AppState {
+    state?: AppStateStateEnum;
+    private 'update_time'?;
+    constructor();
+    withState(state: AppStateStateEnum): AppState;
+    withUpdateTime(updateTime: string): AppState;
+    set updateTime(updateTime: string | undefined);
+    get updateTime(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum AppStateStateEnum {
+    ACTIVATION = "ACTIVATION",
+    DEACTIVATION = "DEACTIVATION",
+    ARREARS = "ARREARS",
+    DELETED = "DELETED"
+}

package/v2/model/AppState.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStateStateEnum = exports.AppState = void 0;
+var AppState = /** @class */ (function () {
+    function AppState() {
+    }
+    AppState.prototype.withState = function (state) {
+        this['state'] = state;
+        return this;
+    };
+    AppState.prototype.withUpdateTime = function (updateTime) {
+        this['update_time'] = updateTime;
+        return this;
+    };
+    Object.defineProperty(AppState.prototype, "updateTime", {
+        get: function () {
+            return this['update_time'];
+        },
+        set: function (updateTime) {
+            this['update_time'] = updateTime;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AppState;
+}());
+exports.AppState = AppState;
+/**
+    * @export
+    * @enum {string}
+    */
+var AppStateStateEnum;
+(function (AppStateStateEnum) {
+    AppStateStateEnum["ACTIVATION"] = "ACTIVATION";
+    AppStateStateEnum["DEACTIVATION"] = "DEACTIVATION";
+    AppStateStateEnum["ARREARS"] = "ARREARS";
+    AppStateStateEnum["DELETED"] = "DELETED";
+})(AppStateStateEnum || (exports.AppStateStateEnum = AppStateStateEnum = {}));

package/v2/model/AutoRecordModeReq.d.ts

@@ -0,0 +1,17 @@
+export declare class AutoRecordModeReq {
+    mode: AutoRecordModeReqModeEnum;
+    private 'record_rule_id'?;
+    constructor(mode?: any);
+    withMode(mode: AutoRecordModeReqModeEnum): AutoRecordModeReq;
+    withRecordRuleId(recordRuleId: string): AutoRecordModeReq;
+    set recordRuleId(recordRuleId: string | undefined);
+    get recordRuleId(): string | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum AutoRecordModeReqModeEnum {
+    AUTO_RECORD_OFF = "AUTO_RECORD_OFF",
+    AUTO_INDIVIDUAL_RECORD = "AUTO_INDIVIDUAL_RECORD"
+}