@snowplow/snowtype-core 0.1.0

package/LICENSE

@@ -0,0 +1,57 @@
+# Snowplow Personal & Academic License Agreement
+
+_Version 1.0, September 2023_
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it, but only for any non-commercial purpose.
+
+Non-commercial purposes include only:
+
+* Personal use for research, experiment, personal study, or hobby projects, without any anticipated commercial application.
+* Use for teaching purposes by lecturers of a school or university.
+* Use to evaluate the sufficiency of the software for the commercial needs of you or your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software for a non-commercial purpose.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice. Otherwise, all your licenses end immediately.
+
+## No Liability
+
+**As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.**
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { LanguageIds, TrackerTemplates } from "./languages";
+export type { LanguageIds, TrackerTemplates };
+export type ScenarioIdentifiers = {
+    name: string;
+    id: string;
+};
+export type DataProduct = {
+    scenario: ScenarioIdentifiers;
+    eventSchema: Schema;
+    entitiesSchemas?: Schema[];
+};
+export type Schema = {
+    [k: string]: unknown;
+};
+export type GenerationInput = {
+    language: LanguageIds;
+    tracker: TrackerTemplates;
+    dataProducts: DataProduct[];
+    schemas: Schema[];
+};
+export declare function generate(input: GenerationInput): Promise<import("quicktype-core").SerializedRenderResult> | undefined;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+const languages_1 = require("./languages");
+const FILE_HEADER = ["Automatically generated by Snowtype"];
+function generate(input) {
+    const selectedLanguageGenerator = languages_1.supportedLanguages.find((lang) => lang.id === input.language);
+    return selectedLanguageGenerator === null || selectedLanguageGenerator === void 0 ? void 0 : selectedLanguageGenerator.generate(input.schemas, input.dataProducts, Object.assign({ header: FILE_HEADER, outputFilename: "snowplow", tracker: input.tracker }, {}));
+}
+exports.generate = generate;

package/dist/json-schema-to-jsdoc/index.d.ts

@@ -0,0 +1 @@
+export declare function generate(schema: any, options?: {}): string;

package/dist/json-schema-to-jsdoc/index.js

@@ -0,0 +1,231 @@
+"use strict";
+/* npm json-schema-to-jsdoc */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+// @ts-nocheck
+const json_pointer_1 = __importDefault(require("json-pointer"));
+function getDefaultPropertyType({ propertyNameAsType, capitalizeProperty, defaultPropertyType }, property) {
+    const fallbackPropertyType = '*';
+    if (property !== undefined && propertyNameAsType) {
+        return capitalizeProperty ? upperFirst(property) : property;
+    }
+    if (defaultPropertyType === null || defaultPropertyType === '') {
+        return defaultPropertyType;
+    }
+    return defaultPropertyType || fallbackPropertyType;
+}
+function wrapDescription(config, description) {
+    const { maxLength } = config;
+    if (!maxLength) {
+        return [description];
+    }
+    const result = [];
+    while (true) {
+        const excess = description.length - config.indentMaxDelta;
+        if (excess <= 0) {
+            if (description) {
+                result.push(description);
+            }
+            break;
+        }
+        const maxLine = description.slice(0, config.indentMaxDelta);
+        const wsIndex = maxLine.search(/\s\S*$/);
+        let safeString;
+        if (wsIndex === -1) {
+            // With this being all non-whitespace, e.g., a long link, we
+            //  let it go on without wrapping until whitespace is reached
+            const remainder = description.slice(config.indentMaxDelta).match(/^\S+/);
+            safeString = maxLine + (remainder || '');
+        }
+        else {
+            safeString = maxLine.slice(0, wsIndex);
+        }
+        result.push(safeString);
+        description = description.slice(safeString.length + 1);
+    }
+    return result;
+}
+function generate(schema, options = {}) {
+    const jsdoc = [];
+    if (!schema || Object.keys(schema).length === 0) {
+        return '';
+    }
+    const config = parseOptions(options);
+    jsdoc.push(...writeDescription(schema, config));
+    if (json_pointer_1.default.has(schema, '/properties')) {
+        jsdoc.push(...processProperties(schema, schema, null, config));
+    }
+    if (json_pointer_1.default.has(schema, '/items')) {
+        jsdoc.push(...processItems(schema, schema, null, config));
+    }
+    return format(config.outerIndent, jsdoc);
+}
+exports.generate = generate;
+function parseOptions(options) {
+    const asteriskAndWhitespaceLength = 3; // ' * '
+    const outerIndent = (options.indentChar || ' ').repeat(options.indent || 0);
+    const indentMaxDelta = options.maxLength - outerIndent.length -
+        asteriskAndWhitespaceLength;
+    return Object.assign(Object.assign({}, options), { outerIndent,
+        indentMaxDelta });
+}
+function processItems(schema, rootSchema, base, config) {
+    const items = json_pointer_1.default.get(schema, '/items');
+    if (!Array.isArray(items)) {
+        return [];
+    }
+    const result = [];
+    items.forEach((item, i) => {
+        const root = base ? `${base}.` : '';
+        const prefixedProperty = root + i;
+        const defaultValue = item.default;
+        const optional = !schema.minItems || i >= schema.minItems;
+        if (item.type === 'array' && item.items) {
+            result.push(...writeProperty('array', prefixedProperty, item.description, optional, defaultValue, config));
+            result.push(...processItems(item, rootSchema, prefixedProperty, config));
+        }
+        else if (item.type === 'object' && item.properties) {
+            result.push(...writeProperty('object', prefixedProperty, item.description, optional, defaultValue, config));
+            result.push(...processProperties(item, rootSchema, prefixedProperty, config));
+        }
+        else {
+            const type = getType(item, rootSchema) || getDefaultPropertyType(config);
+            result.push(...writeProperty(type, prefixedProperty, item.description, optional, defaultValue, config));
+        }
+    });
+    return result;
+}
+function processProperties(schema, rootSchema, base, config) {
+    const props = json_pointer_1.default.get(schema, '/properties');
+    const required = json_pointer_1.default.has(schema, '/required') ? json_pointer_1.default.get(schema, '/required') : [];
+    const result = [];
+    for (const property in props) {
+        if (Array.isArray(config.ignore) && config.ignore.includes(property)) {
+            continue;
+        }
+        else {
+            const prop = props[property];
+            const root = base ? `${base}.` : '';
+            const prefixedProperty = root + property;
+            const defaultValue = props[property].default;
+            const optional = !required.includes(property);
+            if (prop.type === 'object' && prop.properties) {
+                result.push(...writeProperty('object', prefixedProperty, prop.description, optional, defaultValue, config));
+                result.push(...processProperties(prop, rootSchema, prefixedProperty, config));
+            }
+            else if (prop.type === 'array' && prop.items) {
+                result.push(...writeProperty('array', prefixedProperty, prop.description, optional, defaultValue, config));
+                result.push(...processItems(prop, rootSchema, prefixedProperty, config));
+            }
+            else {
+                const type = getType(prop, rootSchema) || getDefaultPropertyType(config, property);
+                result.push(...writeProperty(type, prefixedProperty, prop.description, optional, defaultValue, config));
+            }
+        }
+    }
+    return result;
+}
+function writeDescription(schema, config) {
+    const result = [];
+    const { objectTagName = 'typedef' } = config;
+    let { description } = schema;
+    if (description === undefined) {
+        description = config.autoDescribe ? generateDescription(schema.title, schema.type) : '';
+    }
+    const typeMatch = config.types && config.types[schema.type];
+    let type;
+    if (config.types === null) {
+        type = '';
+    }
+    else {
+        type = ` {${typeMatch === ''
+            ? ''
+            : typeMatch || getType(schema, schema)}}`;
+    }
+    if (description || config.addDescriptionLineBreak) {
+        result.push(...wrapDescription(config, description));
+    }
+    const namepath = schema.title ? ` ${config.capitalizeTitle ? upperFirst(schema.title) : schema.title}` : '';
+    result.push(`@${objectTagName}${type}${namepath}`);
+    return result;
+}
+function writeProperty(type, field, description = '', optional, defaultValue, config) {
+    let fieldTemplate;
+    if (optional) {
+        fieldTemplate = `[${field}${defaultValue === undefined ? '' : `=${JSON.stringify(defaultValue)}`}]`;
+    }
+    else {
+        fieldTemplate = field;
+    }
+    let desc;
+    if (!description && !config.descriptionPlaceholder) {
+        desc = '';
+    }
+    else if (config.hyphenatedDescriptions) {
+        desc = ` - ${description}`;
+    }
+    else {
+        desc = ` ${description}`;
+    }
+    const typeExpression = type === null ? '' : `{${type}} `;
+    return wrapDescription(config, `@property ${typeExpression}${fieldTemplate}${desc}`);
+}
+function getType(schema, rootSchema) {
+    if (schema.$ref) {
+        const ref = json_pointer_1.default.get(rootSchema, schema.$ref.slice(1));
+        return getType(ref, rootSchema);
+    }
+    if (schema.enum) {
+        /* Try to autodetect schema type */
+        if (!schema.type) {
+            // TODO, add condition for enum values with null as option
+            if (typeof schema.enum[0] === "string") {
+                schema.type = 'string';
+            }
+            if ((typeof schema.enum[0]).match(/number|boolean/)) {
+                schema.type = 'number';
+            }
+        }
+        // Try to detect the case of type: ["string", "null"]
+        // enum could be ["foo", "bar", null]
+        if (Array.isArray(schema.type)) {
+            if (schema.type.indexOf('string') !== -1 && schema.type.indexOf('null') !== -1) {
+                return `"${schema.enum.filter(Boolean).join('"|"')}"|null`;
+            }
+        }
+        if (schema.type === 'string') {
+            return `"${schema.enum.join('"|"')}"`;
+        }
+        if (schema.type === 'number' || schema.type === 'integer' ||
+            schema.type === 'boolean') {
+            return `${schema.enum.join('|')}`;
+        }
+        return schema.type === 'null' ? 'null' : 'enum';
+    }
+    if (Array.isArray(schema.type)) {
+        if (schema.type.includes('null')) {
+            return `?${schema.type[0]}`;
+        }
+        else {
+            return schema.type.join('|');
+        }
+    }
+    return schema.type;
+}
+function upperFirst(str) {
+    return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+function generateDescription(title, type) {
+    const noun = title ? `${title} ${type}` : type;
+    const article = `a${'aeiou'.split('').includes(noun.charAt()) ? 'n' : ''}`;
+    return `Represents ${article} ${noun}`;
+}
+function format(outerIndent, lines) {
+    const result = [`${outerIndent}/**`];
+    result.push(...lines.map(line => line ? `${outerIndent} * ${line}` : ' *'));
+    result.push(`${outerIndent} */\n`);
+    return result.join('\n');
+}

package/dist/languages/go.d.ts

@@ -0,0 +1,18 @@
+import { LanguageGenerator, QuicktypeSnowtypeSettings } from "./types";
+import { GoRenderer, GoTargetLanguage, Name, OptionValues, RenderContext, TargetLanguage, Type } from "quicktype-core";
+declare class SnowTypeGoRenderer extends GoRenderer {
+    protected readonly snowtypeOptions: QuicktypeSnowtypeSettings;
+    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, typescriptOptions: OptionValues<any>, snowtypeOptions: QuicktypeSnowtypeSettings);
+    emitSource(givenOutputFilename: string): void;
+    makeNameForTopLevel(t: Type, givenName: string, maybeNamedType: Type | undefined): Name;
+}
+export declare class SnowtypeGoLanguage extends GoTargetLanguage {
+    protected readonly snowtypeOptions: QuicktypeSnowtypeSettings;
+    constructor(snowtypeOptions: QuicktypeSnowtypeSettings);
+    protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
+        [name: string]: any;
+    }): SnowTypeGoRenderer;
+}
+export declare const goBase: LanguageGenerator;
+export declare const go: LanguageGenerator;
+export {};

package/dist/languages/go.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.go = exports.goBase = exports.SnowtypeGoLanguage = void 0;
+const quicktype_utils_1 = require("../quicktype/quicktype-utils");
+const quicktype_core_1 = require("quicktype-core");
+const quicktype_1 = require("../quicktype");
+const Strings_1 = require("quicktype-core/dist/support/Strings");
+class SnowTypeGoRenderer extends quicktype_core_1.GoRenderer {
+    constructor(targetLanguage, renderContext, typescriptOptions, snowtypeOptions) {
+        super(targetLanguage, renderContext, typescriptOptions);
+        this.snowtypeOptions = snowtypeOptions;
+    }
+    emitSource(givenOutputFilename) {
+        super.emitSource(givenOutputFilename);
+        (0, quicktype_utils_1.executeRenderPlan)(this, this.snowtypeOptions.generators);
+    }
+    makeNameForTopLevel(t, givenName, maybeNamedType) {
+        return (0, quicktype_utils_1.makeNameForTopLevelWithPrefixAndSuffix)((...args) => {
+            return super.makeNameForTopLevel(...args);
+        }, this.snowtypeOptions, t, givenName, maybeNamedType);
+    }
+}
+class SnowtypeGoLanguage extends quicktype_core_1.GoTargetLanguage {
+    constructor(snowtypeOptions) {
+        super();
+        this.snowtypeOptions = snowtypeOptions;
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        return new SnowTypeGoRenderer(this, renderContext, (0, quicktype_core_1.getOptionValues)(quicktype_core_1.goOptions, untypedOptionValues), this.snowtypeOptions);
+    }
+}
+exports.SnowtypeGoLanguage = SnowtypeGoLanguage;
+exports.goBase = (0, quicktype_1.createQuicktypeLanguageGenerator)({
+    name: "go",
+    quicktypeLanguage: SnowtypeGoLanguage,
+    defaultOptions: {
+        "just-types": true,
+        "just-types-and-package": true,
+        "package": "main",
+        "multi-file-output": false,
+        "field-tags": "mapstructure",
+    },
+    nameModifiers: {
+        functionName: Strings_1.camelCase,
+    },
+});
+exports.go = Object.assign(Object.assign({}, exports.goBase), { generate: (schemaRepositories, dataProducts, options) => __awaiter(void 0, void 0, void 0, function* () {
+        // @ts-expect-error
+        const { sdk, prefixes, suffixes } = options;
+        const result = yield exports.goBase.generate(schemaRepositories, dataProducts, options);
+        return result;
+    }) });

package/dist/languages/index.d.ts

@@ -0,0 +1,40 @@
+import { LanguageGenerator } from './types';
+export * from './types';
+export { typescript } from './typescript';
+export { javascript } from './javascript';
+export { kotlin } from './kotlin';
+export { swift } from './swift';
+export { go, SnowtypeGoLanguage } from './go';
+export type LanguageIds = "typescript" | "javascript" | "kotlin" | "swift" | "go";
+export interface TrackingScenario {
+    id?: string;
+    version?: number;
+    status?: "draft" | "published" | "deprecated";
+    name: string;
+    description?: string;
+    owner?: string;
+    triggers?: string[];
+    appIds?: string[];
+    event: {
+        source: string;
+        schema?: unknown;
+        [k: string]: unknown;
+    };
+    entities?: {
+        tracked?: {
+            source: string;
+            minCardinality?: number;
+            maxCardinality?: number;
+            [k: string]: unknown;
+        }[];
+        enriched?: {
+            source: string;
+            minCardinality?: number;
+            maxCardinality?: number;
+            [k: string]: unknown;
+        }[];
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export declare const supportedLanguages: LanguageGenerator[];

package/dist/languages/index.js

@@ -0,0 +1,42 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedLanguages = exports.SnowtypeGoLanguage = exports.go = exports.swift = exports.kotlin = exports.javascript = exports.typescript = void 0;
+const javascript_1 = require("./javascript");
+const kotlin_1 = require("./kotlin");
+const swift_1 = require("./swift");
+const typescript_1 = require("./typescript");
+const go_1 = require("./go");
+__exportStar(require("./types"), exports);
+// Export all your languages here
+var typescript_2 = require("./typescript");
+Object.defineProperty(exports, "typescript", { enumerable: true, get: function () { return typescript_2.typescript; } });
+var javascript_2 = require("./javascript");
+Object.defineProperty(exports, "javascript", { enumerable: true, get: function () { return javascript_2.javascript; } });
+var kotlin_2 = require("./kotlin");
+Object.defineProperty(exports, "kotlin", { enumerable: true, get: function () { return kotlin_2.kotlin; } });
+var swift_2 = require("./swift");
+Object.defineProperty(exports, "swift", { enumerable: true, get: function () { return swift_2.swift; } });
+var go_2 = require("./go");
+Object.defineProperty(exports, "go", { enumerable: true, get: function () { return go_2.go; } });
+Object.defineProperty(exports, "SnowtypeGoLanguage", { enumerable: true, get: function () { return go_2.SnowtypeGoLanguage; } });
+exports.supportedLanguages = [
+    typescript_1.typescript,
+    javascript_1.javascript,
+    kotlin_1.kotlin,
+    swift_1.swift,
+    go_1.go
+];

package/dist/languages/javascript.d.ts

@@ -0,0 +1,2 @@
+import { LanguageGenerator } from "./types";
+export declare const javascript: LanguageGenerator;

package/dist/languages/javascript.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascript = void 0;
+const quicktype_utils_1 = require("../quicktype/quicktype-utils");
+const quicktype_core_1 = require("quicktype-core");
+const quicktype_1 = require("../quicktype");
+const metadata_1 = require("../quicktype/metadata");
+// @ts-ignore
+const json_schema_to_jsdoc_1 = require("../json-schema-to-jsdoc");
+const Strings_1 = require("quicktype-core/dist/support/Strings");
+class SnowtypeJavaScriptRenderer extends quicktype_core_1.JavaScriptRenderer {
+    constructor(targetLanguage, renderContext, typescriptOptions, snowtypeOptions) {
+        super(targetLanguage, renderContext, typescriptOptions);
+        this.snowtypeOptions = snowtypeOptions;
+    }
+    emitMultiline(linesString) {
+        (0, quicktype_utils_1.emitMultiline)(this, linesString, 2);
+    }
+    emitSourceStructure() {
+        if (this.leadingComments !== undefined) {
+            this.emitCommentLines(this.leadingComments);
+        }
+        else {
+            this.emitUsageComments();
+        }
+    }
+    emitPredefinedJSDocTypes() {
+        this.emitMultiline(`
+/**
+ * Typedef for a DeviceTimestamp
+ * @typedef {object} DeviceTimestamp
+ * @property {string} type The value of 'dtm'
+ * @property {number} value The value of the device timestamp
+ */
+
+/**
+ * Typedef for a TrueTimestamp
+ * @typedef {object} TrueTimestamp
+ * @property {string} type The value of 'ttm'
+ * @property {number} value The value of the true timestamp
+ */
+
+/**
+ * Typedef for a Timestamp
+ * @typedef {object} Timestamp
+ * @property {number|TrueTimestamp|DeviceTimestamp} [timestamp] The value of the timestamp
+ */
+
+/**
+ * Typedef for a SelfDescribingJson
+ * @typedef {object} SelfDescribingJson
+ * @property {string} schema The schema of the context
+ * @property {object} data The data to send for the context
+ */
+
+/**
+ * Typedef for a Context
+ * @typedef {object} Context
+ * @property {SelfDescribingJson[]} [context] Contexts to include in the event
+ */
+    `);
+        this.ensureBlankLine();
+    }
+    emitSource(givenOutputFilename) {
+        super.emitSource(givenOutputFilename);
+        this.ensureBlankLine();
+        this.emitPredefinedJSDocTypes();
+        this.forEachTopLevel("none", (_, name) => {
+            const title = this.sourcelikeToString(name);
+            const { raw } = _.getAttributes().get(metadata_1.eventMetadataAttributeKind);
+            raw.title = raw.title || title;
+            this.emitMultiline((0, json_schema_to_jsdoc_1.generate)(raw));
+        });
+        (0, quicktype_utils_1.executeRenderPlan)(this, this.snowtypeOptions.generators);
+    }
+    makeNameForTopLevel(t, givenName, maybeNamedType) {
+        return (0, quicktype_utils_1.makeNameForTopLevelWithPrefixAndSuffix)((...args) => {
+            return super.makeNameForTopLevel(...args);
+        }, this.snowtypeOptions, t, givenName, maybeNamedType);
+    }
+}
+// We extend one of the target languages in quicktype to add our own functions
+// This is only necesary to make it use our own renderer
+class SnowtypeJSLanguage extends quicktype_core_1.JavaScriptTargetLanguage {
+    constructor(snowtypeOptions) {
+        super();
+        this.snowtypeOptions = snowtypeOptions;
+    }
+    makeRenderer(renderContext, untypedOptionValues) {
+        return new SnowtypeJavaScriptRenderer(this, renderContext, (0, quicktype_core_1.getOptionValues)(quicktype_core_1.tsFlowOptions, untypedOptionValues), this.snowtypeOptions);
+    }
+}
+const jsBase = (0, quicktype_1.createQuicktypeLanguageGenerator)({
+    name: "javascript",
+    quicktypeLanguage: SnowtypeJSLanguage,
+    defaultOptions: {
+        "runtime-typecheck": false,
+    },
+    nameModifiers: {
+        functionName: Strings_1.camelCase,
+    },
+});
+exports.javascript = Object.assign(Object.assign({}, jsBase), { generate: (schemaRepositories, dataProducts, options) => __awaiter(void 0, void 0, void 0, function* () {
+        // @ts-expect-error
+        const { sdk, prefixes, suffixes } = options;
+        const result = yield jsBase.generate(schemaRepositories, dataProducts, options);
+        return result;
+    }) });

package/dist/languages/kotlin.d.ts

@@ -0,0 +1 @@
+export declare const kotlin: import("./types").LanguageGenerator;