@trayio/tray-schema 0.0.1-beta

package/dist/schema/TJSTraySchemaGenerator.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TJSTraySchemaGenerator = void 0;
+const path_1 = require("path");
+const TJS = __importStar(require("typescript-json-schema"));
+const Either_1 = require("fp-ts/Either");
+const lodash_1 = require("lodash");
+class TJSTraySchemaGenerator {
+    generateFromType(type, path) {
+        const settings = {
+            // this will prevent creating references in the schema when references are used in the types
+            ref: false,
+            // adds support for DDLs and more in the JSdoc annotations
+            validationKeywords: [
+                'lookupInput',
+                'lookupOperation',
+                'lookupAuthRequired',
+                'enumLabels',
+                'advanced',
+            ],
+            // adds a required array to every entitiy in the schema which describes which children are required
+            required: true,
+            // adds "additionalProperties: false" to the schemas
+            noExtraProps: true,
+        };
+        const compilerOptions = {
+            strictNullChecks: true,
+            esModuleInterop: true,
+            // skip checking .d.ts files for type checking to speed up compilation
+            skipLibCheck: true,
+            // don't emit output files; just produce the schema
+            noEmit: true,
+        };
+        const program = TJS.getProgramFromFiles([(0, path_1.resolve)(path)], compilerOptions);
+        const schema = TJS.generateSchema(program, type, settings);
+        if (schema !== null) {
+            const traySchema = this.jsonSchemaToTraySchema(schema);
+            return (0, Either_1.right)(traySchema);
+        }
+        return (0, Either_1.left)(new Error('Failed to generate JSON schema from type'));
+    }
+    jsonSchemaToTraySchema(schema) {
+        const transformLookup = (object) => {
+            if (object.lookupOperation && object.lookupInput) {
+                object.lookup = {
+                    operation: object.lookupOperation,
+                    input: object.lookupInput,
+                    authRequired: object.lookupAuthRequired,
+                };
+                delete object.lookupOperation;
+                delete object.lookupInput;
+                delete object.lookupAuthRequired;
+            }
+        };
+        const transformEnumLabels = (object) => {
+            if (object.enumLabels && typeof object.enumLabels === 'string') {
+                const enumLabelsString = object.enumLabels;
+                const enumLabelsArray = enumLabelsString.split(', ');
+                object.enumLabels = enumLabelsArray;
+            }
+        };
+        const generateEnumLabels = (object) => {
+            if (object.enum && !object.enumLabels && Array.isArray(object.enum)) {
+                const enumLabels = [];
+                const enums = object.enum;
+                enums.forEach((enumItem) => {
+                    if (typeof enumItem === 'string') {
+                        enumLabels.push((0, lodash_1.startCase)((0, lodash_1.camelCase)(enumItem)));
+                    }
+                    else {
+                        enumLabels.push(enumItem.toString());
+                    }
+                });
+                object.enum = enums;
+                object.enumLabels = enumLabels;
+            }
+        };
+        const transformOneOf = (object) => {
+            if (object.anyOf) {
+                object.oneOf = object.anyOf;
+                delete object.anyOf;
+            }
+        };
+        const transformAllOf = (object) => {
+            if (object.allOf && Array.isArray(object.allOf)) {
+                object.allOf.forEach((part) => {
+                    // eslint-disable-next-line no-restricted-syntax
+                    for (const [key, value] of Object.entries(part)) {
+                        if (Array.isArray(value)) {
+                            if (!object[key]) {
+                                object[key] = value;
+                            }
+                            else {
+                                object[key] = [
+                                    ...object[key],
+                                    ...value,
+                                ];
+                            }
+                        }
+                        else if (typeof value === 'object' && value !== null) {
+                            object[key] = Object.assign(Object.assign({}, object[key]), value);
+                        }
+                        else {
+                            object[key] = value;
+                        }
+                    }
+                });
+                delete object.allOf;
+            }
+        };
+        const transformAdvanced = (object) => {
+            if (Object.prototype.hasOwnProperty.call(object, 'properties') &&
+                object.properties !== null) {
+                object.advanced = [];
+                for (const [key, value] of Object.entries(object.properties)) {
+                    if (value.advanced === true) {
+                        object.advanced.push(key);
+                    }
+                    delete value.advanced;
+                }
+            }
+        };
+        const recursiveObjectSearch = (object) => {
+            transformAllOf(object);
+            transformAdvanced(object);
+            for (const [key, value] of Object.entries(object)) {
+                if (typeof value === 'object' && value !== null) {
+                    transformLookup(value);
+                    transformEnumLabels(value);
+                    generateEnumLabels(value);
+                    transformOneOf(value);
+                    recursiveObjectSearch(value);
+                }
+            }
+        };
+        recursiveObjectSearch(schema);
+        return schema;
+    }
+}
+exports.TJSTraySchemaGenerator = TJSTraySchemaGenerator;

package/dist/schema/TJSTraySchemaGenerator.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TJSTraySchemaGenerator.unit.test.d.ts.map

package/dist/schema/TJSTraySchemaGenerator.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TJSTraySchemaGenerator.unit.test.d.ts","sourceRoot":"","sources":["../../src/schema/TJSTraySchemaGenerator.unit.test.ts"],"names":[],"mappings":""}

package/dist/schema/TJSTraySchemaGenerator.unit.test.js

@@ -0,0 +1,432 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const E = __importStar(require("fp-ts/Either"));
+const path_1 = require("path");
+const TJSTraySchemaGenerator_1 = require("./TJSTraySchemaGenerator");
+describe('TJSTraySchemaGenerator', () => {
+    it('Generates data types', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'dataTypes.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                str: { type: 'string' },
+                num: { type: 'number' },
+                int: { type: 'integer' },
+                bool: { type: 'boolean' },
+                obj: {
+                    type: 'object',
+                    properties: {},
+                    advanced: [],
+                    additionalProperties: true,
+                },
+                arr: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {},
+                        advanced: [],
+                        additionalProperties: true,
+                    },
+                },
+            },
+            advanced: [],
+            required: ['arr', 'bool', 'int', 'num', 'obj', 'str'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates reusable parts of the schema by importing types and using typescript intersections', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'importsReusable.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                specificField: { type: 'string' },
+                reusableFields: {
+                    type: 'object',
+                    properties: {
+                        reusableFieldA: { type: 'number' },
+                        reusableFieldB: { type: 'string' },
+                    },
+                    advanced: [],
+                    required: ['reusableFieldA', 'reusableFieldB'],
+                    additionalProperties: false,
+                },
+                reusableSchemaA: { type: 'number' },
+                reusableSchemaB: { type: 'string' },
+            },
+            advanced: [],
+            required: [
+                'reusableFields',
+                'reusableSchemaA',
+                'reusableSchemaB',
+                'specificField',
+            ],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates oneOfs and nested oneOfs from typescript union types by converting anyOfs during post processing', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'oneOf.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                elements: {
+                    title: 'Elements',
+                    description: 'Add images or text to the context. Maximum number of items is 10.',
+                    type: 'array',
+                    items: {
+                        oneOf: [
+                            {
+                                type: 'object',
+                                properties: {
+                                    src: {
+                                        oneOf: [
+                                            {
+                                                type: 'object',
+                                                properties: {
+                                                    path: { type: 'string' },
+                                                    metadata: { type: 'string' },
+                                                },
+                                                advanced: [],
+                                                required: ['metadata', 'path'],
+                                                additionalProperties: false,
+                                            },
+                                            {
+                                                type: 'object',
+                                                properties: { imgId: { type: 'number' } },
+                                                advanced: [],
+                                                required: ['imgId'],
+                                                additionalProperties: false,
+                                            },
+                                        ],
+                                    },
+                                },
+                                advanced: [],
+                                required: ['src'],
+                                additionalProperties: false,
+                            },
+                            {
+                                type: 'object',
+                                properties: {
+                                    msg: {
+                                        title: 'myText',
+                                        description: 'the text.',
+                                        type: 'string',
+                                    },
+                                },
+                                advanced: [],
+                                required: ['msg'],
+                                additionalProperties: false,
+                            },
+                        ],
+                    },
+                },
+            },
+            advanced: [],
+            required: ['elements'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates enums and enumLabels', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'enum.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                actions: {
+                    description: 'example dropdown',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            text: { type: 'string' },
+                            type: {
+                                enumLabels: ['Default Always', 'The Danger', 'Primary One'],
+                                enum: ['default always', 'the_danger', 'primary-one'],
+                                type: 'string',
+                            },
+                        },
+                        advanced: [],
+                        required: ['text', 'type'],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            advanced: [],
+            required: ['actions'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates enums and custom enumLabels', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'enumLabels.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                actions: {
+                    description: 'example dropdown',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            text: { type: 'string' },
+                            type: {
+                                enumLabels: ['The Default', 'The Danger', 'The Primary'],
+                                enum: ['default', 'danger', 'primary'],
+                                type: 'string',
+                            },
+                        },
+                        advanced: [],
+                        required: ['text', 'type'],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            advanced: [],
+            required: ['actions'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates DDL lookup format during post processing', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'ddl.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                emails: {
+                    type: 'string',
+                    lookup: {
+                        operation: 'list_users_actual_ddl',
+                        input: {
+                            include_private_channels: false,
+                            workspace_id: '{{{workspace_id}}}',
+                        },
+                    },
+                },
+            },
+            advanced: [],
+            required: ['emails'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates DDL lookup format including authRequired during post processing', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'ddlAuth.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                emails: {
+                    type: 'string',
+                    lookup: {
+                        operation: 'list_users_actual_ddl',
+                        input: {
+                            include_private_channels: false,
+                            workspace_id: '{{{workspace_id}}}',
+                        },
+                        authRequired: true,
+                    },
+                },
+            },
+            advanced: [],
+            required: ['emails'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates required fields array based on typescripts optional (?) symbol', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'required.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                mandatoryField: { type: 'string' },
+                optionalField: { type: 'string' },
+            },
+            advanced: [],
+            required: ['mandatoryField'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates format properties from JSdoc annotations', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'format.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                timestamp: { format: 'datetime', type: 'string' },
+                html: { format: 'code', type: 'string' },
+                longNotes: { format: 'text', type: 'string' },
+                password: { format: 'password', type: 'string' },
+                file: { format: 'file', type: 'string' },
+            },
+            advanced: [],
+            required: ['file', 'html', 'longNotes', 'password', 'timestamp'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates default properties from JSdoc annotations', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'default.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                str: { default: 'string default', type: 'string' },
+                num: { default: 0.1, type: 'number' },
+                int: { type: 'integer', default: 1 },
+                bool: { default: true, type: 'boolean' },
+                obj: {
+                    default: { default: true },
+                    type: 'object',
+                    properties: {},
+                    advanced: [],
+                    additionalProperties: true,
+                },
+                arr: {
+                    default: ['default'],
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {},
+                        advanced: [],
+                        additionalProperties: true,
+                    },
+                },
+            },
+            advanced: [],
+            required: ['arr', 'bool', 'int', 'num', 'obj', 'str'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates advanced fields array', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'advanced.test.data.ts');
+        const result = new TJSTraySchemaGenerator_1.TJSTraySchemaGenerator().generateFromType(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                advancedField: { type: 'string' },
+                normalField: {
+                    type: 'object',
+                    properties: {
+                        normalField: { type: 'string' },
+                        advancedField: { type: 'string' },
+                    },
+                    advanced: ['advancedField'],
+                    additionalProperties: false,
+                },
+            },
+            advanced: ['advancedField'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+});

package/dist/schema/TraySchemaGenerator.d.ts

@@ -0,0 +1,6 @@
+import { Either } from 'fp-ts/lib/Either';
+import { DynamicObject } from '@trayio/commons/dynamictype/DynamicType';
+export interface TraySchemaGenerator {
+    generateFromType(type: string, path: string): Either<Error, DynamicObject>;
+}
+//# sourceMappingURL=TraySchemaGenerator.d.ts.map

package/dist/schema/TraySchemaGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraySchemaGenerator.d.ts","sourceRoot":"","sources":["../../src/schema/TraySchemaGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAExE,MAAM,WAAW,mBAAmB;IACnC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;CAC3E"}

package/dist/schema/TraySchemaGenerator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/advanced.test.data.d.ts

@@ -0,0 +1,14 @@
+export type Input = {
+    /**
+     * @advanced true
+     */
+    advancedField?: string;
+    normalField?: {
+        /**
+         * @advanced true
+         */
+        advancedField?: string;
+        normalField?: string;
+    };
+};
+//# sourceMappingURL=advanced.test.data.d.ts.map

package/dist/schema/advanced.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/advanced.test.data.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG;IACnB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE;QACb;;WAEG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACF,CAAC"}

package/dist/schema/advanced.test.data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/dataTypes.test.data.d.ts

@@ -0,0 +1,12 @@
+export type Input = {
+    str: string;
+    num: number;
+    /**
+     * @TJS-type integer
+     */
+    int: number;
+    bool: boolean;
+    obj: object;
+    arr: object[];
+};
+//# sourceMappingURL=dataTypes.test.data.d.ts.map

package/dist/schema/dataTypes.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataTypes.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/dataTypes.test.data.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,EAAE,CAAC;CACd,CAAC"}

package/dist/schema/dataTypes.test.data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema/ddl.test.data.d.ts

@@ -0,0 +1,8 @@
+export type Input = {
+    /**
+     * @lookupOperation list_users_actual_ddl
+     * @lookupInput {"include_private_channels": false,"workspace_id": "{{{workspace_id}}}"}
+     */
+    emails: string;
+};
+//# sourceMappingURL=ddl.test.data.d.ts.map

package/dist/schema/ddl.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/ddl.test.data.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG;IACnB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CACf,CAAC"}