@cognigy/rest-api-client 0.9.1 → 0.12.0

package/build/shared/helper/rest/operations.js

@@ -1,19 +1,20 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBatchOperations = void 0;
 /* Custom Modules */
 const errors_1 = require("../../errors");
 let defaultMaxAmountOfOperationsPerBatchCall = 100;
 // @ts-ignore
-const { MAX_AMOUNT_OF_OPERATIONS_PER_BATCH_CALL } = (_a = process) === null || _a === void 0 ? void 0 : _a.env;
+const { MAX_AMOUNT_OF_OPERATIONS_PER_BATCH_CALL } = process === null || process === void 0 ? void 0 : process.env;
 if (MAX_AMOUNT_OF_OPERATIONS_PER_BATCH_CALL) {
     defaultMaxAmountOfOperationsPerBatchCall = parseInt(MAX_AMOUNT_OF_OPERATIONS_PER_BATCH_CALL, 10);
 }
-exports.validateBatchOperations = (operations, loggerStack, maxAmountOfOperationsPerBatchCall) => {
+const validateBatchOperations = (operations, loggerStack, maxAmountOfOperationsPerBatchCall) => {
     maxAmountOfOperationsPerBatchCall = maxAmountOfOperationsPerBatchCall || defaultMaxAmountOfOperationsPerBatchCall;
     if (Array.isArray(operations) &&
         operations.length > maxAmountOfOperationsPerBatchCall) {
         throw new errors_1.BadRequestError(`Only ${maxAmountOfOperationsPerBatchCall} operations per batch call allowed`, loggerStack);
     }
 };
+exports.validateBatchOperations = validateBatchOperations;
 //# sourceMappingURL=operations.js.map

package/build/shared/helper/rest/query-string/decode-uri-component.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeComponent = void 0;
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp(token, 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
+function decodeComponents(components, split = 1) {
+    try {
+        // Try to decode the entire string first
+        return decodeURIComponent(components.join(''));
+    }
+    catch (err) {
+        // Do nothing
+    }
+    if (components.length === 1) {
+        return components;
+    }
+    // Split the array in 2 parts
+    const left = components.slice(0, split);
+    const right = components.slice(split);
+    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+    try {
+        return decodeURIComponent(input);
+    }
+    catch (err) {
+        let tokens = input.match(singleMatcher);
+        for (let i = 1; i < tokens.length; i++) {
+            input = decodeComponents(tokens, i).join('');
+            tokens = input.match(singleMatcher);
+        }
+        return input;
+    }
+}
+function customDecodeURIComponent(input) {
+    // Keep track of all the replacements and prefill the map with the `BOM`
+    const replaceMap = {
+        '%FE%FF': '\uFFFD\uFFFD',
+        '%FF%FE': '\uFFFD\uFFFD'
+    };
+    let match = multiMatcher.exec(input);
+    while (match) {
+        try {
+            // Decode as big chunks as possible
+            replaceMap[match[0]] = decodeURIComponent(match[0]);
+        }
+        catch (err) {
+            const result = decode(match[0]);
+            if (result !== match[0]) {
+                replaceMap[match[0]] = result;
+            }
+        }
+        match = multiMatcher.exec(input);
+    }
+    // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+    replaceMap['%C2'] = '\uFFFD';
+    const entries = Object.keys(replaceMap);
+    for (let i = 0; i < entries.length; i++) {
+        // Replace all decoded components
+        const key = entries[i];
+        input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+    }
+    return input;
+}
+function decodeComponent(encodedURI) {
+    if (typeof encodedURI !== 'string') {
+        throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+    }
+    try {
+        encodedURI = encodedURI.replace(/\+/g, ' ');
+        // Try the built in decoder first
+        return decodeURIComponent(encodedURI);
+    }
+    catch (err) {
+        // Fallback to a more advanced decoder
+        return customDecodeURIComponent(encodedURI);
+    }
+}
+exports.decodeComponent = decodeComponent;
+;
+//# sourceMappingURL=decode-uri-component.js.map

package/build/shared/helper/rest/query-string/index.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyUrl = exports.parseUrl = exports.stringify = exports.parse = exports.parseValue = exports.extract = exports.getHash = exports.removeHash = exports.keysSorter = exports.decode = exports.encode = exports.validateArrayFormatSeparator = exports.parserForArrayFormat = exports.encoderForArrayFormat = void 0;
+const decode_uri_component_1 = require("./decode-uri-component");
+const splitOnFirst_1 = require("./splitOnFirst");
+const strictUriEncode_1 = require("./strictUriEncode");
+const isNullOrUndefined = value => value === null || value === undefined;
+function encoderForArrayFormat(options) {
+    switch (options.arrayFormat) {
+        case 'index':
+            return key => (result, value) => {
+                const index = result.length;
+                if (value === undefined ||
+                    (options.skipNull && value === null) ||
+                    (options.skipEmptyString && value === '')) {
+                    return result;
+                }
+                if (value === null) {
+                    return [...result, [encode(key, options), '[', index, ']'].join('')];
+                }
+                return [
+                    ...result,
+                    [encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
+                ];
+            };
+        case 'bracket':
+            return key => (result, value) => {
+                if (value === undefined ||
+                    (options.skipNull && value === null) ||
+                    (options.skipEmptyString && value === '')) {
+                    return result;
+                }
+                if (value === null) {
+                    return [...result, [encode(key, options), '[]'].join('')];
+                }
+                return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
+            };
+        case 'comma':
+        case 'separator':
+            return key => (result, value) => {
+                if (value === null || value === undefined || value.length === 0) {
+                    return result;
+                }
+                if (result.length === 0) {
+                    return [[encode(key, options), '=', encode(value, options)].join('')];
+                }
+                return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+            };
+        default:
+            return key => (result, value) => {
+                if (value === undefined ||
+                    (options.skipNull && value === null) ||
+                    (options.skipEmptyString && value === '')) {
+                    return result;
+                }
+                if (value === null) {
+                    return [...result, encode(key, options)];
+                }
+                return [...result, [encode(key, options), '=', encode(value, options)].join('')];
+            };
+    }
+}
+exports.encoderForArrayFormat = encoderForArrayFormat;
+function parserForArrayFormat(options) {
+    let result;
+    switch (options.arrayFormat) {
+        case 'index':
+            return (key, value, accumulator) => {
+                result = /\[(\d*)\]$/.exec(key);
+                key = key.replace(/\[\d*\]$/, '');
+                if (!result) {
+                    accumulator[key] = value;
+                    return;
+                }
+                if (accumulator[key] === undefined) {
+                    accumulator[key] = {};
+                }
+                accumulator[key][result[1]] = value;
+            };
+        case 'bracket':
+            return (key, value, accumulator) => {
+                result = /(\[\])$/.exec(key);
+                key = key.replace(/\[\]$/, '');
+                if (!result) {
+                    accumulator[key] = value;
+                    return;
+                }
+                if (accumulator[key] === undefined) {
+                    accumulator[key] = [value];
+                    return;
+                }
+                accumulator[key] = [].concat(accumulator[key], value);
+            };
+        case 'comma':
+        case 'separator':
+            return (key, value, accumulator) => {
+                const isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
+                const isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));
+                value = isEncodedArray ? decode(value, options) : value;
+                const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
+                accumulator[key] = newValue;
+            };
+        default:
+            return (key, value, accumulator) => {
+                if (accumulator[key] === undefined) {
+                    accumulator[key] = value;
+                    return;
+                }
+                accumulator[key] = [].concat(accumulator[key], value);
+            };
+    }
+}
+exports.parserForArrayFormat = parserForArrayFormat;
+function validateArrayFormatSeparator(value) {
+    if (typeof value !== 'string' || value.length !== 1) {
+        throw new TypeError('arrayFormatSeparator must be single character string');
+    }
+}
+exports.validateArrayFormatSeparator = validateArrayFormatSeparator;
+function encode(value, options) {
+    if (options.encode) {
+        return options.strict ? strictUriEncode_1.strictUriEncode(value) : encodeURIComponent(value);
+    }
+    return value;
+}
+exports.encode = encode;
+function decode(value, options) {
+    if (options.decode) {
+        return decode_uri_component_1.decodeComponent(value);
+    }
+    return value;
+}
+exports.decode = decode;
+function keysSorter(input) {
+    if (Array.isArray(input)) {
+        return input.sort();
+    }
+    if (typeof input === 'object') {
+        return keysSorter(Object.keys(input))
+            .sort((a, b) => Number(a) - Number(b))
+            .map(key => input[key]);
+    }
+    return input;
+}
+exports.keysSorter = keysSorter;
+function removeHash(input) {
+    const hashStart = input.indexOf('#');
+    if (hashStart !== -1) {
+        input = input.slice(0, hashStart);
+    }
+    return input;
+}
+exports.removeHash = removeHash;
+function getHash(url) {
+    let hash = '';
+    const hashStart = url.indexOf('#');
+    if (hashStart !== -1) {
+        hash = url.slice(hashStart);
+    }
+    return hash;
+}
+exports.getHash = getHash;
+function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf('?');
+    if (queryStart === -1) {
+        return '';
+    }
+    return input.slice(queryStart + 1);
+}
+exports.extract = extract;
+function parseValue(value, options) {
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
+        value = Number(value);
+    }
+    else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+        value = value.toLowerCase() === 'true';
+    }
+    return value;
+}
+exports.parseValue = parseValue;
+function parse(query, options) {
+    options = Object.assign({
+        decode: true,
+        sort: true,
+        arrayFormat: 'none',
+        arrayFormatSeparator: ',',
+        parseNumbers: false,
+        parseBooleans: false
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+    // Create an object with no prototype
+    const ret = Object.create(null);
+    if (typeof query !== 'string') {
+        return ret;
+    }
+    query = query.trim().replace(/^[?#&]/, '');
+    if (!query) {
+        return ret;
+    }
+    for (const param of query.split('&')) {
+        let [key, value] = splitOnFirst_1.splitOnFirst(options.decode ? param.replace(/\+/g, ' ') : param, '=');
+        // Missing `=` should be `null`:
+        // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+        value = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);
+        formatter(decode(key, options), value, ret);
+    }
+    for (const key of Object.keys(ret)) {
+        const value = ret[key];
+        if (typeof value === 'object' && value !== null) {
+            for (const k of Object.keys(value)) {
+                value[k] = parseValue(value[k], options);
+            }
+        }
+        else {
+            ret[key] = parseValue(value, options);
+        }
+    }
+    if (options.sort === false) {
+        return ret;
+    }
+    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+        const value = ret[key];
+        if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
+            // Sort object keys, not values
+            result[key] = keysSorter(value);
+        }
+        else {
+            result[key] = value;
+        }
+        return result;
+    }, Object.create(null));
+}
+exports.parse = parse;
+const stringify = (object, options) => {
+    if (!object) {
+        return '';
+    }
+    options = Object.assign({
+        encode: true,
+        strict: true,
+        arrayFormat: 'none',
+        arrayFormatSeparator: ','
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = key => ((options.skipNull && isNullOrUndefined(object[key])) ||
+        (options.skipEmptyString && object[key] === ''));
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const key of Object.keys(object)) {
+        if (!shouldFilter(key)) {
+            objectCopy[key] = object[key];
+        }
+    }
+    const keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+        keys.sort(options.sort);
+    }
+    return keys.map(key => {
+        const value = object[key];
+        if (value === undefined) {
+            return '';
+        }
+        if (value === null) {
+            return encode(key, options);
+        }
+        if (Array.isArray(value)) {
+            return value
+                .reduce(formatter(key), [])
+                .join('&');
+        }
+        return encode(key, options) + '=' + encode(value, options);
+    }).filter(x => x.length > 0).join('&');
+};
+exports.stringify = stringify;
+const parseUrl = (url, options) => {
+    options = Object.assign({
+        decode: true
+    }, options);
+    const [url_, hash] = splitOnFirst_1.splitOnFirst(url, '#');
+    return Object.assign({
+        url: url_.split('?')[0] || '',
+        query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {});
+};
+exports.parseUrl = parseUrl;
+const stringifyUrl = (object, options) => {
+    options = Object.assign({
+        encode: true,
+        strict: true
+    }, options);
+    const url = removeHash(object.url).split('?')[0] || '';
+    const queryFromUrl = extract(object.url);
+    const parsedQueryFromUrl = parse(queryFromUrl, { sort: false });
+    const query = Object.assign(parsedQueryFromUrl, object.query);
+    let queryString = exports.stringify(query, options);
+    if (queryString) {
+        queryString = `?${queryString}`;
+    }
+    let hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+        hash = `#${encode(object.fragmentIdentifier, options)}`;
+    }
+    return `${url}${queryString}${hash}`;
+};
+exports.stringifyUrl = stringifyUrl;
+//# sourceMappingURL=index.js.map

package/build/shared/helper/rest/query-string/splitOnFirst.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitOnFirst = void 0;
+const splitOnFirst = (string, separator) => {
+    if (!(typeof string === 'string' && typeof separator === 'string')) {
+        throw new TypeError('Expected the arguments to be of type `string`');
+    }
+    if (string === '' || separator === '') {
+        return [];
+    }
+    const separatorIndex = string.indexOf(separator);
+    if (separatorIndex === -1) {
+        return [];
+    }
+    return [
+        string.slice(0, separatorIndex),
+        string.slice(separatorIndex + separator.length)
+    ];
+};
+exports.splitOnFirst = splitOnFirst;
+//# sourceMappingURL=splitOnFirst.js.map

package/build/shared/helper/rest/query-string/strictUriEncode.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strictUriEncode = void 0;
+const strictUriEncode = (string) => encodeURIComponent(string)
+    .replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+exports.strictUriEncode = strictUriEncode;
+//# sourceMappingURL=strictUriEncode.js.map

package/build/shared/helper/rest/skip.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSkip = (skip) => {
+exports.parseSkip = void 0;
+const parseSkip = (skip) => {
     if (typeof skip === "undefined") {
         return undefined;
     }
     return Math.max(parseInt(skip, 10), 0);
 };
+exports.parseSkip = parseSkip;
 //# sourceMappingURL=skip.js.map

package/build/shared/helper/rest/sort.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifySort = (sort) => {
+exports.parseSort = exports.stringifySort = void 0;
+const stringifySort = (sort) => {
     return Object
         .keys(sort)
         .map(key => {
@@ -8,7 +9,8 @@ exports.stringifySort = (sort) => {
     })
         .join(",");
 };
-exports.parseSort = (sort) => {
+exports.stringifySort = stringifySort;
+const parseSort = (sort) => {
     if (typeof sort === "undefined") {
         return undefined;
     }
@@ -19,4 +21,5 @@ exports.parseSort = (sort) => {
         return pV;
     }, {});
 };
+exports.parseSort = parseSort;
 //# sourceMappingURL=sort.js.map

package/build/shared/interfaces/BatchOperation.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.actionOperationSchemaGenerator = (data) => {
+exports.actionOperationSchemaGenerator = void 0;
+const actionOperationSchemaGenerator = (data) => {
     const { action, commonKeys, hasId = true, valueSchema, } = data;
     const schema = {
         type: "object",
@@ -10,10 +11,6 @@ exports.actionOperationSchemaGenerator = (data) => {
             op: { type: "string", enum: [action] },
         },
     };
-    if (hasId) {
-        schema.required.push("id");
-        schema.properties.id = { type: "string", format: "mongo-id" };
-    }
     if (valueSchema) {
         schema.required.push("value");
         const operationSchema = JSON.parse(JSON.stringify(valueSchema));
@@ -29,6 +26,17 @@ exports.actionOperationSchemaGenerator = (data) => {
         }
         schema.properties.value = operationSchema;
     }
+    if (hasId) {
+        schema.required.push("id");
+        schema.properties.id = { type: "string", format: "mongo-id" };
+        if (valueSchema) {
+            const clonedSchema = JSON.parse(JSON.stringify(valueSchema));
+            if (clonedSchema.properties.id) {
+                schema.properties.id = clonedSchema.properties.id;
+            }
+        }
+    }
     return schema;
 };
+exports.actionOperationSchemaGenerator = actionOperationSchemaGenerator;
 //# sourceMappingURL=BatchOperation.js.map

package/build/shared/interfaces/IApiKey.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyQuerySchema = exports.apiKeySchema = exports.generateApiKeyRedisKeys = void 0;
+/* Custom Modules */
+const createQuerySchema_1 = require("../helper/createQuerySchema");
+const generateApiKeyRedisKeys = (data) => {
+    return [
+        `apiKey:${data.apiKey}`,
+    ];
+};
+exports.generateApiKeyRedisKeys = generateApiKeyRedisKeys;
+exports.apiKeySchema = {
+    title: "apiKeyDataSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        _id: { type: "string", format: "mongo-id" },
+        createdAt: { type: "integer", format: "timestamp" },
+        name: { type: "string", format: "resource-name" },
+        apiKey: { type: "string", format: "alphanum-64" },
+        organisationReference: { type: "string", format: "mongo-id" },
+        userReference: { type: "string", format: "mongo-id" },
+        ttl: { type: "integer", maximum: 3 * 365 * 24 * 60 * 60 * 1000, minimum: 0 },
+        expiresAt: { type: "object" },
+    }
+};
+exports.apiKeyQuerySchema = createQuerySchema_1.createQuerySchema("apiKeyQuerySchema", exports.apiKeySchema);
+//# sourceMappingURL=IApiKey.js.map

package/build/shared/interfaces/IEndpointTranslationSettings.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translationSettingsEndpointSchema = void 0;
+exports.translationSettingsEndpointSchema = {
+    title: "translationSettingsEndpointSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        translationEnabled: {
+            type: "boolean"
+        },
+        flowLanguage: {
+            type: "string"
+        },
+        inputLanguage: {
+            type: "string"
+        },
+        noTranslateMarker: {
+            type: "string"
+        },
+        padPayloads: {
+            type: "boolean"
+        },
+        alwaysRemoveNoTranslateMarker: {
+            type: "boolean",
+        },
+        setInputLanguageOnExecutionCount: {
+            type: "number",
+        },
+    }
+};
+//# sourceMappingURL=IEndpointTranslationSettings.js.map

package/build/shared/interfaces/IFunctionInstanceParameters.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionInstanceParametersSchema = void 0;
+exports.functionInstanceParametersSchema = {
+    title: "functionInstanceParametersSchema",
+    type: "object",
+    additionalProperties: true,
+    properties: {
+        traceId: { type: "string" },
+        userId: { type: "string" },
+        sessionId: { type: "string" },
+        flowReferenceId: { type: "string", format: "uuid" },
+    }
+};
+//# sourceMappingURL=IFunctionInstanceParameters.js.map

package/build/shared/interfaces/IHandoverRequestStatus.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IHandoverRequestStatus.js.map

package/build/shared/interfaces/IHttpRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IHttpRequest.js.map

package/build/shared/interfaces/IOrganisation.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.organisationQuerySchema = exports.organisationSchema = exports.organisationDataSchema = exports.organisationPasswordPolicySchema = exports.generateOrganisationRedisKeys = void 0;
+/* Custom Modules */
+const createQuerySchema_1 = require("../helper/createQuerySchema");
+const generateOrganisationRedisKeys = (data) => {
+    return [
+        `organisationId:${data.organisationId}`,
+    ];
+};
+exports.generateOrganisationRedisKeys = generateOrganisationRedisKeys;
+exports.organisationPasswordPolicySchema = {
+    title: "organisationPasswordPolicySchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        maxAmountIdenticalCharacters: { type: "integer", minimum: 0, maximum: 999 },
+        maxLength: { type: "integer", minimum: 0, maximum: 999 },
+        minAmountFailedAttemptsAutoDisable: { type: "integer", minimum: 0, maximum: 999 },
+        minAmountLowerCase: { type: "integer", minimum: 0, maximum: 999 },
+        minAmountNumbers: { type: "integer", minimum: 0, maximum: 999 },
+        minAmountSpecialCharacters: { type: "integer", minimum: 0, maximum: 999 },
+        minAmountUpperCase: { type: "integer", minimum: 0, maximum: 999 },
+        minLength: { type: "integer", minimum: 0, maximum: 999 },
+    },
+};
+exports.organisationDataSchema = {
+    title: "organisationDataSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        contactProfileTTLInMinutes: { type: "integer", minimum: 0 },
+        conversationTTLInMinutes: { type: "integer", minimum: 0 },
+        disabled: { type: "boolean" },
+        name: { type: "string", minLength: 1, format: "resource-name" },
+        passwordPolicy: exports.organisationPasswordPolicySchema,
+        quotaMaxChannelsPerProject: { type: "integer", minimum: 0 },
+        quotaMaxMessagesPerDay: { type: "integer", minimum: 0 },
+        quotaMaxProjects: { type: "integer", minimum: 0 },
+        quotaMaxUsers: { type: "integer", minimum: 0 },
+        sessionStateTTLInMinutes: { type: "integer", minimum: 0 },
+    },
+};
+exports.organisationSchema = {
+    title: "organisationSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: Object.assign(Object.assign({ _id: { format: "mongo-id" } }, exports.organisationDataSchema.properties), { liveAgentAccount: { type: "number" } }),
+};
+exports.organisationQuerySchema = createQuerySchema_1.createQuerySchema("organisationQuerySchema", exports.organisationSchema);
+//# sourceMappingURL=IOrganisation.js.map