@quonfig/cli 0.0.1

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+async function main() {
+  const {execute} = await import('@oclif/core')
+  await execute({dir: import.meta.url})
+}
+
+await main()

package/dist/api/get-environments.d.ts

@@ -0,0 +1,10 @@
+import type { APICommand } from '../index.js';
+export interface Environment {
+    active?: boolean;
+    deletedAt?: number | null;
+    id: string;
+    name: string;
+    protected?: boolean;
+    type?: string;
+}
+export declare const getEnvironments: (command: APICommand) => Promise<Environment[]>;

package/dist/api/get-environments.js

@@ -0,0 +1,11 @@
+export const getEnvironments = async (command) => {
+    const request = await command.apiClient.post('/api/v1/environments/list', { workspaceId: command.workspaceId });
+    if (!request.ok) {
+        const errorMsg = request.error?.error || `Failed to fetch environments: ${request.status}`;
+        return command.err(errorMsg, { serverError: request.error });
+    }
+    // oRPC returns the array directly (not wrapped in { environments: [] })
+    const environments = (Array.isArray(request.json) ? request.json : request.json.environments);
+    // Filter out deleted environments and sort by name
+    return environments.filter((env) => !env.deletedAt).sort((a, b) => a.name.localeCompare(b.name));
+};

package/dist/codegen/code-generators/base-generator.d.ts

@@ -0,0 +1,11 @@
+import { type ConfigFile } from '../types.js';
+export interface BaseGeneratorArgs {
+    configFile: ConfigFile;
+    log: (category: string | unknown, message?: unknown) => void;
+}
+export declare abstract class BaseGenerator {
+    protected configFile: ConfigFile;
+    protected log: (category: string | unknown, message?: unknown) => void;
+    constructor({ configFile, log }: BaseGeneratorArgs);
+    abstract generate(): string;
+}

package/dist/codegen/code-generators/base-generator.js

@@ -0,0 +1,8 @@
+export class BaseGenerator {
+    configFile;
+    log;
+    constructor({ configFile, log }) {
+        this.configFile = configFile;
+        this.log = log;
+    }
+}

package/dist/codegen/code-generators/base-typescript-generator.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { BaseGenerator, BaseGeneratorArgs } from './base-generator.js';
+export declare abstract class BaseTypescriptGenerator extends BaseGenerator {
+    protected MUSTACHE_IMPORT: string;
+    private schemaExtractor;
+    constructor({ configFile, log }: BaseGeneratorArgs);
+    protected configurations(): {
+        configType: "CONFIG" | "FEATURE_FLAG" | "SCHEMA";
+        hasFunction: boolean;
+        key: string;
+        schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        sendToClientSdk: boolean;
+    }[];
+    protected durationTypeMap(): z.ZodTypeAny;
+    abstract declarationGenerate(): string;
+    abstract generate(): string;
+}

package/dist/codegen/code-generators/base-typescript-generator.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ZodToTypescriptMapper } from '../language-mappers/zod-to-typescript-mapper.js';
+import { SchemaExtractor } from '../schema-extractor.js';
+import { BaseGenerator } from './base-generator.js';
+export class BaseTypescriptGenerator extends BaseGenerator {
+    MUSTACHE_IMPORT = "import Mustache from 'mustache'";
+    schemaExtractor;
+    constructor({ configFile, log }) {
+        super({ configFile, log });
+        this.schemaExtractor = new SchemaExtractor(log);
+    }
+    configurations() {
+        return this.configFile.configs
+            .filter((config) => config.configType === 'FEATURE_FLAG' || config.configType === 'CONFIG')
+            .filter((config) => config.rows.length > 0)
+            .sort((a, b) => a.key.localeCompare(b.key))
+            .map((config) => {
+            const schema = this.schemaExtractor.execute({
+                config,
+                configFile: this.configFile,
+                durationTypeMap: this.durationTypeMap,
+            });
+            return {
+                configType: config.configType,
+                hasFunction: schema && new ZodToTypescriptMapper().resolveType(schema).includes('=>'),
+                key: config.key,
+                schema,
+                sendToClientSdk: config.sendToClientSdk ?? false,
+            };
+        });
+    }
+    durationTypeMap() {
+        return z.number();
+    }
+}

package/dist/codegen/code-generators/node-typescript-generator.d.ts

@@ -0,0 +1,8 @@
+import { BaseTypescriptGenerator } from './base-typescript-generator.js';
+export declare class NodeTypeScriptGenerator extends BaseTypescriptGenerator {
+    declarationGenerate(): string;
+    generate(): string;
+    private additionalDependencies;
+    private generateAccessorMethods;
+    private generateSchemaTypes;
+}

package/dist/codegen/code-generators/node-typescript-generator.js

@@ -0,0 +1,96 @@
+import { stripIndent } from 'common-tags';
+import camelCase from 'lodash.camelcase';
+import { ZodToTypescriptMapper } from '../language-mappers/zod-to-typescript-mapper.js';
+import { ZodToTypescriptReturnValueMapper } from '../language-mappers/zod-to-typescript-return-value-mapper.js';
+import { BaseTypescriptGenerator } from './base-typescript-generator.js';
+export class NodeTypeScriptGenerator extends BaseTypescriptGenerator {
+    declarationGenerate() {
+        return (stripIndent `
+    /* eslint-disable */
+    // AUTOGENERATED by quonfig-cli's 'gen' command
+    // prettier-ignore
+    import "@quonfig/node";
+
+    // prettier-ignore
+    declare module "@quonfig/node" {
+      export interface NodeServerConfigurationRaw {
+        ${this.generateSchemaTypes('raw').join('\n        ') || '// No types generated'}
+      }
+
+      export interface NodeServerConfigurationAccessor {
+        ${this.generateSchemaTypes().join('\n        ') || '// No types generated'}
+      }
+    }
+    ` + '\n' // For adding newline to avoid prettier issues
+        );
+    }
+    generate() {
+        return (stripIndent `
+    /* eslint-disable */
+    // AUTOGENERATED by quonfig-cli's 'gen' command
+    // prettier-ignore
+    import { Quonfig, Contexts, TypedNodeServerConfigurationRaw, TypedNodeServerConfigurationAccessor } from '@quonfig/node'
+    // prettier-ignore
+    ${this.additionalDependencies().join('\n// prettier-ignore\n') || '// No additional dependencies required'}
+
+    // prettier-ignore
+    type ContextObj = Record<string, Record<string, unknown>>
+
+    // prettier-ignore
+    export class QuonfigTypesafeNode {
+      constructor(public quonfig: Quonfig) { }
+
+      get<K extends keyof TypedNodeServerConfigurationRaw>(key: K, contexts?: Contexts | ContextObj): TypedNodeServerConfigurationRaw[K] {
+        return this.quonfig.get(key, contexts) as TypedNodeServerConfigurationRaw[K]
+      }
+
+      ${this.generateAccessorMethods().join('\n\n      ') || '// No methods generated'}
+    }
+    ` + '\n' // For adding newline to avoid prettier issues
+        );
+    }
+    additionalDependencies() {
+        const dependencies = [];
+        const hasFunctions = this.configurations().some((c) => c.hasFunction);
+        if (hasFunctions) {
+            dependencies.push(this.MUSTACHE_IMPORT);
+        }
+        return dependencies;
+    }
+    generateAccessorMethods() {
+        const uniqueMethods = {};
+        const schemaTypes = this.configurations().map((config) => {
+            let methodName = camelCase(config.key);
+            // If the method name starts with a digit, prefix it with an underscore to ensure method name is valid
+            if (/^\d/.test(methodName)) {
+                methodName = `_${methodName}`;
+            }
+            if (uniqueMethods[methodName]) {
+                throw new Error(`Method '${methodName}' is already registered. Quonfig key ${config.key} conflicts with '${uniqueMethods[methodName]}'!`);
+            }
+            uniqueMethods[methodName] = config.key;
+            if (config.hasFunction) {
+                const returnValue = new ZodToTypescriptReturnValueMapper().resolveType(config.schema);
+                return stripIndent `
+          ${methodName}(contexts?: Contexts | ContextObj): TypedNodeServerConfigurationAccessor['${config.key}'] {
+                  const raw = this.get('${config.key}', contexts)
+                  return ${returnValue}
+                }
+          `;
+            }
+            return stripIndent `
+        ${methodName}(contexts?: Contexts | ContextObj): TypedNodeServerConfigurationAccessor['${config.key}'] {
+                return this.get('${config.key}', contexts)
+              }
+          `;
+        });
+        return schemaTypes;
+    }
+    generateSchemaTypes(target = 'accessor') {
+        const schemaTypes = this.configurations().flatMap((config) => {
+            const mapper = new ZodToTypescriptMapper({ fieldName: config.key, target });
+            return mapper.renderField(config.schema);
+        });
+        return schemaTypes;
+    }
+}

package/dist/codegen/code-generators/react-typescript-generator.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { BaseTypescriptGenerator } from './base-typescript-generator.js';
+export declare class ReactTypeScriptGenerator extends BaseTypescriptGenerator {
+    declarationGenerate(): string;
+    protected durationTypeMap(): z.ZodTypeAny;
+    generate(): string;
+    private additionalDependencies;
+    private filteredConfigurations;
+    private generateAccessorMethods;
+    private generateSchemaTypes;
+}

package/dist/codegen/code-generators/react-typescript-generator.js

@@ -0,0 +1,116 @@
+import { stripIndent } from 'common-tags';
+import camelCase from 'lodash.camelcase';
+import { z } from 'zod';
+import { ZodToTypescriptMapper } from '../language-mappers/zod-to-typescript-mapper.js';
+import { ZodToTypescriptReturnValueMapper } from '../language-mappers/zod-to-typescript-return-value-mapper.js';
+import { BaseTypescriptGenerator } from './base-typescript-generator.js';
+export class ReactTypeScriptGenerator extends BaseTypescriptGenerator {
+    declarationGenerate() {
+        return (stripIndent `
+    /* eslint-disable */
+    // AUTOGENERATED by quonfig-cli's 'gen' command
+    // prettier-ignore
+    import "@quonfig/javascript";
+    // prettier-ignore
+    import "@quonfig/react";
+
+    // prettier-ignore
+    declare module "@quonfig/javascript" {
+      export interface FrontEndConfigurationRaw {
+        ${this.generateSchemaTypes('raw').join('\n        ') || '// No types generated'}
+      }
+
+      // Force TypedFrontEndConfigurationRaw to always use our merged interface
+      export type TypedFrontEndConfigurationRaw = FrontEndConfigurationRaw;
+    }
+
+    // prettier-ignore
+    declare module "@quonfig/react" {
+      export interface FrontEndConfigurationAccessor {
+        ${this.generateSchemaTypes().join('\n        ') || '// No types generated'}
+      }
+
+      // Force TypedFrontEndConfigurationRaw to always use our merged interface
+      export type TypedFrontEndConfigurationAccessor = FrontEndConfigurationAccessor;
+    }
+    ` + '\n' // For adding newline to avoid prettier issues
+        );
+    }
+    durationTypeMap() {
+        return z.object({ ms: z.number(), seconds: z.number() });
+    }
+    generate() {
+        return (stripIndent `
+    /* eslint-disable */
+    // AUTOGENERATED by quonfig-cli's 'gen' command
+    // prettier-ignore
+    import { Quonfig, TypedFrontEndConfigurationRaw } from "@quonfig/javascript"
+    // prettier-ignore
+    import { createQuonfigHook, TypedFrontEndConfigurationAccessor } from "@quonfig/react"
+    // prettier-ignore
+    ${this.additionalDependencies().join('\n// prettier-ignore\n') || '// No additional dependencies required'}
+
+    // prettier-ignore
+    export class QuonfigTypesafeReact {
+      constructor(public quonfig: Quonfig) { }
+
+      get<K extends keyof TypedFrontEndConfigurationRaw>(key: K): TypedFrontEndConfigurationRaw[K] {
+        return this.quonfig.get(key) as TypedFrontEndConfigurationRaw[K]
+      }
+
+      ${this.generateAccessorMethods().join('\n\n      ') || '// No methods generated'}
+    }
+
+    // prettier-ignore
+    export const useQuonfig = createQuonfigHook(QuonfigTypesafeReact)
+    ` + '\n' // For adding newline to avoid prettier issues
+        );
+    }
+    additionalDependencies() {
+        const dependencies = [];
+        const hasFunctions = this.filteredConfigurations().some((c) => c.hasFunction);
+        if (hasFunctions) {
+            dependencies.push(this.MUSTACHE_IMPORT);
+        }
+        return dependencies;
+    }
+    filteredConfigurations() {
+        return this.configurations().filter((config) => config.configType === 'FEATURE_FLAG' || config.sendToClientSdk === true);
+    }
+    generateAccessorMethods() {
+        const uniqueMethods = {};
+        const schemaTypes = this.filteredConfigurations().map((config) => {
+            let methodName = camelCase(config.key);
+            // If the method name starts with a digit, prefix it with an underscore to ensure method name is valid
+            if (/^\d/.test(methodName)) {
+                methodName = `_${methodName}`;
+            }
+            if (uniqueMethods[methodName]) {
+                throw new Error(`Method '${methodName}' is already registered. Quonfig key ${config.key} conflicts with '${uniqueMethods[methodName]}'!`);
+            }
+            uniqueMethods[methodName] = config.key;
+            if (config.hasFunction) {
+                const returnValue = new ZodToTypescriptReturnValueMapper().resolveType(config.schema);
+                return stripIndent `
+          ${methodName}(): TypedFrontEndConfigurationAccessor['${config.key}'] {
+                  const raw = this.get('${config.key}')
+                  return ${returnValue}
+                }
+          `;
+            }
+            return stripIndent `
+        get ${methodName}(): TypedFrontEndConfigurationAccessor['${config.key}'] {
+                return this.get('${config.key}')
+              }
+        `;
+        });
+        return schemaTypes;
+    }
+    generateSchemaTypes(target = 'accessor') {
+        const schemaTypes = this.filteredConfigurations().map((config) => {
+            const mapper = new ZodToTypescriptMapper({ fieldName: config.key, target });
+            return mapper.renderField(config.schema);
+        });
+        return schemaTypes;
+    }
+}

package/dist/codegen/config-downloader.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigFile } from './types.js';
+import { APICommand } from '../index.js';
+export declare class ConfigDownloader {
+    private command;
+    constructor(command: APICommand);
+    downloadConfig(): Promise<ConfigFile>;
+}

package/dist/codegen/config-downloader.js

@@ -0,0 +1,26 @@
+export class ConfigDownloader {
+    command;
+    constructor(command) {
+        this.command = command;
+    }
+    async downloadConfig() {
+        try {
+            const response = (await this.command.apiClient.get('/all-config-types/v1/download-all-envs'));
+            if (!response.ok) {
+                throw new Error(`Failed to download config: ${response.status}`);
+            }
+            // Parse the response data - configs are nested in response.data.json
+            const configData = response.json;
+            // Print out each config key
+            this.command.verboseLog('\nFound configurations:', configData.configs?.length || 0);
+            if (!configData.configs) {
+                throw new Error('Invalid response format');
+            }
+            return configData;
+        }
+        catch (error) {
+            console.error('Error downloading config:', error);
+            throw error;
+        }
+    }
+}

package/dist/codegen/json-schema-to-zod.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare function isLegacySchemaWrapper(schema: unknown): boolean;
+export declare function jsonSchemaToZod(schema: unknown): z.ZodTypeAny;

package/dist/codegen/json-schema-to-zod.js

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function toMeta(schema) {
+    const meta = {};
+    if (typeof schema.title === 'string') {
+        meta.title = schema.title;
+    }
+    if (typeof schema.description === 'string') {
+        meta.description = schema.description;
+    }
+    return Object.keys(meta).length > 0 ? meta : undefined;
+}
+function applyMeta(schema, meta) {
+    return meta ? schema.meta(meta) : schema;
+}
+function literalFromEnum(values) {
+    if (values.length === 0) {
+        return z.never();
+    }
+    if (values.every((value) => typeof value === 'string')) {
+        return z.enum(values);
+    }
+    if (values.length === 1) {
+        return z.literal(values[0]);
+    }
+    const literals = values.map((value) => z.literal(value));
+    return z.union(literals);
+}
+function schemaFromTypeArray(schema, types) {
+    const nonNullTypes = types.filter((item) => item !== 'null');
+    const includesNull = nonNullTypes.length !== types.length;
+    if (nonNullTypes.length === 0 && includesNull) {
+        return z.null();
+    }
+    if (nonNullTypes.length === 1) {
+        const resolved = schemaToZod({ ...schema, type: nonNullTypes[0] });
+        return includesNull ? resolved.nullable() : resolved;
+    }
+    const resolved = z.union(nonNullTypes.map((type) => schemaToZod({ ...schema, type })));
+    return includesNull ? resolved.nullable() : resolved;
+}
+function schemaFromObject(schema) {
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    const required = new Set(Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === 'string') : []);
+    const shape = {};
+    for (const [key, value] of Object.entries(properties)) {
+        const propertySchema = schemaToZod(value);
+        shape[key] = required.has(key) ? propertySchema : propertySchema.optional();
+    }
+    const base = z.object(shape);
+    if (schema.additionalProperties === false) {
+        return base.strict();
+    }
+    if (isObject(schema.additionalProperties) && Object.keys(properties).length === 0) {
+        return z.record(z.string(), schemaToZod(schema.additionalProperties));
+    }
+    return base;
+}
+function schemaToZod(schema) {
+    if (!isObject(schema)) {
+        return z.any();
+    }
+    const meta = toMeta(schema);
+    let result;
+    if (Array.isArray(schema.enum)) {
+        result = literalFromEnum(schema.enum);
+    }
+    else if (schema.const !== undefined) {
+        result = z.literal(schema.const);
+    }
+    else if (Array.isArray(schema.type)) {
+        result = schemaFromTypeArray(schema, schema.type);
+    }
+    else {
+        switch (schema.type) {
+            case 'string': {
+                result = z.string();
+                break;
+            }
+            case 'number': {
+                result = z.number();
+                break;
+            }
+            case 'integer': {
+                result = z.number().int();
+                break;
+            }
+            case 'boolean': {
+                result = z.boolean();
+                break;
+            }
+            case 'null': {
+                result = z.null();
+                break;
+            }
+            case 'array': {
+                if (Array.isArray(schema.prefixItems)) {
+                    const items = schema.prefixItems.map((item) => schemaToZod(item));
+                    result = z.tuple(items);
+                }
+                else if (schema.items !== undefined) {
+                    result = z.array(schemaToZod(schema.items));
+                }
+                else {
+                    result = z.array(z.any());
+                }
+                break;
+            }
+            case 'object':
+            case undefined: {
+                if (schema.properties || schema.additionalProperties !== undefined || schema.required) {
+                    result = schemaFromObject(schema);
+                }
+                else {
+                    result = z.object({});
+                }
+                break;
+            }
+            default: {
+                if (Array.isArray(schema.oneOf)) {
+                    const options = schema.oneOf.map((item) => schemaToZod(item));
+                    result = options.length === 1 ? options[0] : z.union(options);
+                    break;
+                }
+                if (Array.isArray(schema.anyOf)) {
+                    const options = schema.anyOf.map((item) => schemaToZod(item));
+                    result = options.length === 1 ? options[0] : z.union(options);
+                    break;
+                }
+                if (Array.isArray(schema.allOf) && schema.allOf.length === 1) {
+                    result = schemaToZod(schema.allOf[0]);
+                    break;
+                }
+                if (schema.not === false) {
+                    result = z.never();
+                    break;
+                }
+                result = z.any();
+            }
+        }
+    }
+    if (schema.default !== undefined) {
+        result = result.default(schema.default);
+    }
+    result = applyMeta(result, meta);
+    return result;
+}
+export function isLegacySchemaWrapper(schema) {
+    if (!isObject(schema)) {
+        return false;
+    }
+    const defaultSection = schema.default;
+    if (!isObject(defaultSection) || !Array.isArray(defaultSection.rules)) {
+        return false;
+    }
+    const firstRule = defaultSection.rules[0];
+    if (!isObject(firstRule)) {
+        return false;
+    }
+    const value = firstRule.value;
+    if (!isObject(value) || !isObject(value.schema)) {
+        return false;
+    }
+    return typeof value.schema.schema === 'string';
+}
+export function jsonSchemaToZod(schema) {
+    return schemaToZod(schema);
+}

package/dist/codegen/language-mappers/json-to-zod-mapper.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare class JsonToZodMapper {
+    resolve(data: unknown): z.ZodTypeAny;
+}

package/dist/codegen/language-mappers/json-to-zod-mapper.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export class JsonToZodMapper {
+    resolve(data) {
+        if (Array.isArray(data)) {
+            if (data.length > 0) {
+                // Check if all elements in the array have the same type
+                const firstItem = data[0];
+                const isHomogeneous = data.every((item) => {
+                    const itemsMatch = typeof item === typeof firstItem;
+                    // Special handling for objects and arrays
+                    if (typeof firstItem === 'object') {
+                        if (Array.isArray(item)) {
+                            return Array.isArray(firstItem);
+                        }
+                        return !Array.isArray(firstItem);
+                    }
+                    return itemsMatch;
+                });
+                // For homogeneous arrays, use the first element's type
+                if (isHomogeneous) {
+                    return z.array(this.resolve(data[0]));
+                }
+                // Explicitly do not handle mixed-type arrays
+                // They could be tuples or heterogeneous arrays
+                // Instead, we return an array of unknowns
+            }
+            return z.array(z.unknown());
+        }
+        if (typeof data === 'object' && data !== null) {
+            const shape = {};
+            const dataRecord = data;
+            for (const key in dataRecord) {
+                if (Object.hasOwn(dataRecord, key)) {
+                    shape[key] = this.resolve(dataRecord[key]);
+                }
+            }
+            return z.object(shape);
+        }
+        if (typeof data === 'string') {
+            return z.string();
+        }
+        if (typeof data === 'number') {
+            return z.number();
+        }
+        if (typeof data === 'boolean') {
+            return z.boolean();
+        }
+        if (data === null) {
+            return z.null();
+        }
+        console.warn(`Unknown json type:`, data);
+        // If the type is not recognized, default to 'any'
+        return z.any();
+    }
+}

package/dist/codegen/language-mappers/zod-base-mapper.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { $ZodFunctionArgs, $ZodFunctionOut, $ZodType, util } from 'zod/v4/core';
+export declare abstract class ZodBaseMapper {
+    resolveType(type: $ZodType): string;
+    /**
+     * Hook for handling meta descriptions on schemas.
+     * By default, this just returns the resolved type without any modification.
+     * Subclasses can override this to add comments or other metadata handling.
+     *
+     * @param description The description from .meta({ description: "..." })
+     * @param resolveType A function that resolves the inner type
+     * @returns The type string, potentially with description metadata
+     */
+    protected withMeta(description: string, resolveType: () => string): string;
+    private resolveTypeInternal;
+    protected abstract any(): string;
+    protected abstract array(wrappedType: string): string;
+    protected abstract boolean(): string;
+    protected abstract enum(values: util.EnumValue[]): string;
+    protected abstract function(args: string, returns: string): string;
+    protected abstract functionArguments(value?: $ZodFunctionArgs): string;
+    protected abstract functionReturns(value: $ZodFunctionOut): string;
+    protected abstract null(): string;
+    protected abstract literal(value: string | number | boolean | null): string;
+    protected abstract number(isInteger: boolean): string;
+    protected abstract object(properties: [string, z.ZodTypeAny][]): string;
+    protected abstract optional(wrappedType: string): string;
+    protected abstract never(): string;
+    protected abstract record(keyType: string, valueType: string): string;
+    protected abstract string(): string;
+    protected abstract tuple(wrappedTypes: string[]): string;
+    protected abstract undefined(): string;
+    protected abstract union(wrappedTypes: string[]): string;
+    protected abstract unknown(): string;
+}