@cognigy/rest-api-client 0.20.0 → 4.94.0

package/dist/esm/shared/helper/rest/query-string/index.js

@@ -0,0 +1,291 @@
+import { decodeComponent } from "./decode-uri-component";
+import { splitOnFirst } from "./splitOnFirst";
+import { strictUriEncode } from "./strictUriEncode";
+const isNullOrUndefined = value => value === null || value === undefined;
+export 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('')];
+            };
+    }
+}
+export 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);
+            };
+    }
+}
+export function validateArrayFormatSeparator(value) {
+    if (typeof value !== 'string' || value.length !== 1) {
+        throw new TypeError('arrayFormatSeparator must be single character string');
+    }
+}
+export function encode(value, options) {
+    if (options.encode) {
+        return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+    }
+    return value;
+}
+export function decode(value, options) {
+    if (options.decode) {
+        return decodeComponent(value);
+    }
+    return value;
+}
+export 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;
+}
+export function removeHash(input) {
+    const hashStart = input.indexOf('#');
+    if (hashStart !== -1) {
+        input = input.slice(0, hashStart);
+    }
+    return input;
+}
+export function getHash(url) {
+    let hash = '';
+    const hashStart = url.indexOf('#');
+    if (hashStart !== -1) {
+        hash = url.slice(hashStart);
+    }
+    return hash;
+}
+export function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf('?');
+    if (queryStart === -1) {
+        return '';
+    }
+    return input.slice(queryStart + 1);
+}
+export 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;
+}
+export 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(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));
+}
+export 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('&');
+};
+export const parseUrl = (url, options) => {
+    options = Object.assign({
+        decode: true
+    }, options);
+    const [url_, hash] = splitOnFirst(url, '#');
+    return Object.assign({
+        url: url_.split('?')[0] || '',
+        query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {});
+};
+export 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 = stringify(query, options);
+    if (queryString) {
+        queryString = `?${queryString}`;
+    }
+    let hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+        hash = `#${encode(object.fragmentIdentifier, options)}`;
+    }
+    return `${url}${queryString}${hash}`;
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/shared/helper/rest/query-string/splitOnFirst.js

@@ -0,0 +1,17 @@
+export 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)
+    ];
+};
+//# sourceMappingURL=splitOnFirst.js.map

package/dist/esm/shared/helper/rest/query-string/strictUriEncode.js

@@ -0,0 +1,3 @@
+export const strictUriEncode = (string) => encodeURIComponent(string)
+    .replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+//# sourceMappingURL=strictUriEncode.js.map

package/dist/esm/shared/helper/rest/skip.js

@@ -0,0 +1,7 @@
+export const parseSkip = (skip) => {
+    if (typeof skip === "undefined") {
+        return undefined;
+    }
+    return Math.max(parseInt(skip, 10), 0);
+};
+//# sourceMappingURL=skip.js.map

package/dist/esm/shared/helper/rest/sort.js

@@ -0,0 +1,20 @@
+export const stringifySort = (sort) => {
+    return Object
+        .keys(sort)
+        .map(key => {
+        return `${key}:${sort[key]}`;
+    })
+        .join(",");
+};
+export const parseSort = (sort) => {
+    if (typeof sort === "undefined") {
+        return undefined;
+    }
+    return sort
+        .split(",")
+        .reduce((pV, cV) => {
+        pV[cV.split(":")[0]] = cV.split(":")[1] === "desc" ? -1 : 1;
+        return pV;
+    }, {});
+};
+//# sourceMappingURL=sort.js.map

package/dist/esm/shared/interfaces/BatchOperation.js

@@ -0,0 +1,38 @@
+export const actionOperationSchemaGenerator = (data) => {
+    const { action, commonKeys, hasId = true, valueSchema, } = data;
+    const schema = {
+        type: "object",
+        additionalProperties: false,
+        required: ["op"],
+        properties: {
+            op: { type: "string", enum: [action] },
+        },
+    };
+    if (valueSchema) {
+        schema.required.push("value");
+        const operationSchema = JSON.parse(JSON.stringify(valueSchema));
+        if (operationSchema.required) {
+            for (const key of commonKeys) {
+                const indexOfKey = operationSchema.required.indexOf(key);
+                if (indexOfKey !== -1) {
+                    operationSchema.required[indexOfKey] = operationSchema.required[operationSchema.required.length - 1];
+                    operationSchema.required.pop();
+                }
+                delete operationSchema.properties[key];
+            }
+        }
+        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;
+};
+//# sourceMappingURL=BatchOperation.js.map

package/dist/esm/shared/interfaces/IApiKey.js

@@ -0,0 +1,20 @@
+/* Custom Modules */
+import { createQuerySchema } from "../helper/createQuerySchema";
+export const 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" },
+        schemaVersion: { type: "integer", minimum: 1 },
+    }
+};
+export const apiKeyQuerySchema = createQuerySchema("apiKeyQuerySchema", apiKeySchema);
+//# sourceMappingURL=IApiKey.js.map

package/dist/esm/shared/interfaces/IEndpointSettings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IEndpointSettings.js.map

package/dist/esm/shared/interfaces/IEndpointTranslationSettings.js

@@ -0,0 +1,38 @@
+export const translationSettingsEndpointSchema = {
+    title: "translationSettingsEndpointSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        translationEnabled: {
+            type: "boolean"
+        },
+        flowLanguage: {
+            type: "string"
+        },
+        inputLanguage: {
+            type: "string"
+        },
+        noTranslateMarker: {
+            type: "string"
+        },
+        glossaryId: {
+            type: "string"
+        },
+        glossaryIdInput: {
+            type: "string"
+        },
+        formality: {
+            type: "string"
+        },
+        padPayloads: {
+            type: "boolean"
+        },
+        alwaysRemoveNoTranslateMarker: {
+            type: "boolean",
+        },
+        setInputLanguageOnExecutionCount: {
+            type: "number",
+        },
+    }
+};
+//# sourceMappingURL=IEndpointTranslationSettings.js.map

package/dist/esm/shared/interfaces/IFunctionInstanceParameters.js

@@ -0,0 +1,12 @@
+export const 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/dist/esm/shared/interfaces/IHandoverRequestStatus.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHandoverRequestStatus.js.map

package/dist/esm/shared/interfaces/IHttpRequest.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHttpRequest.js.map

package/dist/esm/shared/interfaces/IOrganisation.js

@@ -0,0 +1,64 @@
+/* Custom Modules */
+import { createQuerySchema } from "../helper/createQuerySchema";
+export const organisationDataPrivacySettingsSchema = {
+    title: "organisationDataPrivacySettingsSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        useAnalytics: { type: "boolean" },
+        storeDataPayload: { type: "boolean" },
+        useContactProfiles: { type: "boolean" },
+        useConversations: { type: "boolean" },
+        maskIPAddress: { type: "boolean" },
+        maskAnalytics: { type: "boolean" },
+        maskLogging: { type: "boolean" },
+        ignoreList: { type: "array", items: { type: "string" }, additionalItems: false, minItems: 0 }
+    },
+};
+export const 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 },
+    },
+};
+export const organisationDataSchema = {
+    title: "organisationDataSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        contactProfileTTLInMinutes: { type: "integer", minimum: 0 },
+        conversationTTLInMinutes: { type: "integer", minimum: 0 },
+        analyticsTTLInMinutes: { type: "integer", minimum: 0 },
+        sessionsTTLInMinutes: { type: "integer", minimum: 0 },
+        stepEventsTTLInMinutes: { type: "integer", minimum: 0 },
+        disabled: { type: "boolean" },
+        name: { type: "string", minLength: 1, format: "resource-name" },
+        passwordPolicy: organisationPasswordPolicySchema,
+        quotaMaxChannelsPerProject: { type: "integer", minimum: 0 },
+        quotaMaxMessagesPerDay: { type: "integer", minimum: 0 },
+        quotaMaxProjects: { type: "integer", minimum: 0 },
+        quotaMaxUsers: { type: "integer", minimum: 0 },
+        quotaMaxKnowledgeChunks: { type: "integer", minimum: 0 },
+        sessionStateTTLInMinutes: { type: "integer", minimum: 0 },
+        billingTimezone: { type: "string", format: "timezone" },
+        dataPrivacySettings: organisationDataPrivacySettingsSchema,
+    },
+};
+export const organisationSchema = {
+    title: "organisationSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: Object.assign(Object.assign({ _id: { format: "mongo-id" } }, organisationDataSchema.properties), { liveAgentAccount: { type: "number" }, voiceGatewayAccount: { type: "string" } }),
+};
+export const organisationQuerySchema = createQuerySchema("organisationQuerySchema", organisationSchema);
+//# sourceMappingURL=IOrganisation.js.map

package/dist/esm/shared/interfaces/IProfile.js

@@ -0,0 +1,24 @@
+/* Custom Modules */
+import { createQuerySchema } from "../helper/createQuerySchema";
+import { entityMetaSchema } from "./resources/IEntityMeta";
+;
+;
+export const profileDataSchema = {
+    title: "profileDataSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        active: { type: "boolean" },
+        contactIds: { type: "array", items: { type: "string" }, additionalItems: false, minItems: 1 },
+        expiresAt: { type: "object" },
+        profile: {},
+    },
+};
+export const profileSchema = {
+    title: "profileSchema",
+    type: "object",
+    additionalProperties: false,
+    properties: Object.assign(Object.assign(Object.assign({}, profileDataSchema.properties), entityMetaSchema.properties), { projectReference: { type: "string", format: "mongo-id" }, organisationReference: { type: "string", format: "mongo-id" } }),
+};
+export const profileQuerySchema = createQuerySchema("profileQuerySchema", profileSchema);
+//# sourceMappingURL=IProfile.js.map

package/dist/esm/shared/interfaces/IProfileSchema.js

@@ -0,0 +1,41 @@
+import { entityMetaSchema } from "./resources/IEntityMeta";
+export const profileEntrySchemaTypes = ["string", "object", "number", "boolean"];
+export const profileSchemaEntry = {
+    title: "profileSchemaEntry",
+    type: "object",
+    required: ["field", "internal", "type"],
+    properties: {
+        field: { type: "string" },
+        internal: { type: "string", format: "profile-schema-entry-internal" },
+        type: { type: "string", format: "profile-schema-entry-type" }
+    },
+};
+export const profileSchemaSchema = {
+    title: "profileSchemaSchema",
+    type: "object",
+    properties: Object.assign(Object.assign({}, entityMetaSchema.properties), { details: { type: "array", items: profileSchemaEntry, additionalItems: false }, schema: {
+            additionalProperties: {
+                type: "string",
+                propertyNames: { type: "string" },
+                enum: ["string", "object", "number", "boolean"]
+            },
+        } }),
+};
+export const defaultProfile = {
+    firstname: "",
+    lastname: "",
+    email: "",
+    age: 0,
+    birthday: "",
+    gender: "",
+    location: "",
+    profilepic: "",
+    prevent_data_collection: false,
+    accepted_gdpr: false,
+    privacy_policy: {
+        accepted: false
+    },
+    goals: [],
+    memories: [],
+};
+//# sourceMappingURL=IProfileSchema.js.map

package/dist/esm/shared/interfaces/ISayNodeSettings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISayNodeSettings.js.map

package/dist/esm/shared/interfaces/ISessionScope.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISessionScope.js.map

package/dist/esm/shared/interfaces/TEntrypointType.js

@@ -0,0 +1,2 @@
+export const entrypointType = ["project", "snapshot"];
+//# sourceMappingURL=TEntrypointType.js.map

package/dist/esm/shared/interfaces/TFunctionInstanceStatus.js

@@ -0,0 +1,7 @@
+export const functionInstanceStatus = [
+    "queued",
+    "active",
+    "done",
+    "error",
+];
+//# sourceMappingURL=TFunctionInstanceStatus.js.map

package/dist/esm/shared/interfaces/TFunctionInstanceTrigger.js

@@ -0,0 +1,5 @@
+export const functionInstanceTrigger = [
+    "flow",
+    "manual",
+];
+//# sourceMappingURL=TFunctionInstanceTrigger.js.map

package/dist/esm/shared/interfaces/agentAssist/ISendConfigUpdateParams.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISendConfigUpdateParams.js.map

package/dist/esm/shared/interfaces/agentAssist/ISendTileUpdateParams.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISendTileUpdateParams.js.map

package/dist/esm/shared/interfaces/agentAssist/ISendUpdateReferenceParams.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ISendUpdateReferenceParams.js.map

package/dist/esm/shared/interfaces/agentAssist/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/esm/shared/interfaces/ai.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ai.js.map

package/dist/esm/shared/interfaces/alexa/IAccumulatedAlexaResponse.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAccumulatedAlexaResponse.js.map

package/dist/esm/shared/interfaces/alexa/IAlexaCard.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAlexaCard.js.map

package/dist/esm/shared/interfaces/alexa/IAlexaDirective.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAlexaDirective.js.map

package/dist/esm/shared/interfaces/alexa/IAlexaDisplayDirective.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAlexaDisplayDirective.js.map