stellate 1.13.2 → 1.14.2

package/build/CLI.d.ts

@@ -0,0 +1,10 @@
+import { Command, Commands } from './types';
+/**
+ * CLI command
+ */
+export declare class CLI implements Command {
+    private readonly cmds;
+    constructor(cmds: Commands);
+    parse(argv: string[]): Promise<string>;
+    private static help;
+}

package/build/Check.d.ts

@@ -0,0 +1,6 @@
+import { Command } from './types';
+export declare class Check implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/Help.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unknown command
+ */
+export declare function unknownCommand(helpTemplate: string, cmd: string): HelpError;
+/**
+ * Custom help error used to display help
+ * errors without printing a stack trace
+ */
+export declare class HelpError extends Error {
+    constructor(msg: string);
+}

package/build/Init.d.ts

@@ -0,0 +1,9 @@
+import { Command } from './types';
+/**
+ * $ stellate version
+ */
+export declare class Init implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/List.d.ts

@@ -0,0 +1,9 @@
+import { Command } from './types';
+/**
+ * $ stellate ls
+ */
+export declare class List implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/Login.d.ts

@@ -0,0 +1,12 @@
+import { Command } from './types';
+/**
+ * $ stellate login
+ */
+export declare class Login implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    private handleExistingToken;
+    requestToken(): Promise<string>;
+    private persistToken;
+    help(error?: string): string;
+}

package/build/Pull.d.ts

@@ -0,0 +1,19 @@
+import { Command } from './types';
+/**
+ * $ stellate pull
+ * Pull yml.app, write to root
+
+ * $ stellate pull --app <app>
+ * Pull <app>, write config to root
+
+ * stellate pull --env <env>
+ * Pull yml.<env>.app, write env-specific settings to environments.<env> and everything else to root
+
+ * stellate pull --app <app> --env <env>
+ * Pull <app>, write env-specific settings to environments.<env> and everything else to root
+ */
+export declare class Pull implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/Push.d.ts

@@ -0,0 +1,6 @@
+import { Command } from './types';
+export declare class Push implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/Serve.d.ts

@@ -0,0 +1,23 @@
+import { Input } from '@gcdn/configuration';
+import { Command } from './types';
+declare type ServeCacheEntry = {
+    checksum: string;
+    envName: string;
+    purgeToken?: string;
+};
+declare type ServeCache = {
+    [appName: string]: ServeCacheEntry;
+};
+export declare class Serve implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    setupPurgingProxy(name: string, servePort: number): Promise<void>;
+    setupApiProxy(name: string, servePort: number): void;
+    ensureConfig(): void;
+    getCache(): ServeCache;
+    getCacheEntry(appName?: string): ServeCacheEntry;
+    getChecksum(input: Input): string;
+    writePurgeToken(appName: string, purgeToken: string): void;
+    writeCache(appName: string, input: Input, envName: string): ServeCacheEntry;
+}
+export {};

package/build/Version.d.ts

@@ -0,0 +1,9 @@
+import { Command } from './types';
+/**
+ * $ stellate version
+ */
+export declare class Version implements Command {
+    private static help;
+    parse(argv: string[]): Promise<string>;
+    help(error?: string): string;
+}

package/build/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/build/client.d.ts

@@ -0,0 +1,9 @@
+export declare class AppNotFoundError extends Error {
+    constructor(message: any);
+}
+export declare const baseUrl: string;
+export declare class BaseClient {
+    private readonly token?;
+    constructor(token?: string | undefined);
+    query<T>(query: string, variables?: any): Promise<T>;
+}

package/build/configFile.d.ts

@@ -0,0 +1,8 @@
+import { Input } from '@gcdn/configuration';
+export declare type ConfigFormat = 'yml' | 'ts' | 'js' | 'mjs';
+export declare const detectConfigFormat: () => ConfigFormat;
+declare const readConfig: (envName?: string | null) => Promise<Input | null>;
+declare const updateConfig: (input: Input, envName?: string | null) => Promise<void>;
+declare const getAppName: (input: Input | null, appName?: string | null) => string;
+declare const hasConfig: () => Promise<boolean>;
+export { readConfig, updateConfig, hasConfig, getAppName };

package/build/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const configDir: string;
+export declare const deprecatedConfigDir: string;
+export declare const tokenPath: string;
+export declare const deprecatedTokenPath: string;
+export declare const serveCache: string;

package/build/getToken.d.ts

@@ -0,0 +1 @@
+export declare function getToken(triggerLogin?: boolean): Promise<string>;

package/build/helpers/checkPrinting.d.ts

@@ -0,0 +1,13 @@
+import { EnumValueChange, FieldArgumentRemoval, FieldArgumentTypeChange, FieldRemoval, FieldTypeChange, SchemaChange, TypeRemoval } from './checkTypes';
+declare type Severity = 'warning' | 'error';
+export declare const getBoxText: ({ severity }: {
+    severity: Severity;
+}) => string;
+export declare const printTypeRemoval: (severity: Severity, e: TypeRemoval) => string;
+export declare const printFieldRemoval: (severity: Severity, e: FieldRemoval) => string;
+export declare const printFieldArgumentRemoval: (severity: Severity, e: FieldArgumentRemoval) => string;
+export declare const printFieldTypeChange: (severity: Severity, e: FieldTypeChange) => string;
+export declare const printFieldArgumentTypeChange: (severity: Severity, e: FieldArgumentTypeChange) => string;
+export declare const printEnumValueChange: (severity: Severity, e: EnumValueChange) => string;
+export declare const printSchemaChange: (severity: 'warning' | 'error', e: SchemaChange) => string;
+export {};

package/build/helpers/checkPrinting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/helpers/checkTypes.d.ts

@@ -0,0 +1,161 @@
+export declare type SchemaChange = TypeRemoval | FieldRemoval | FieldArgumentRemoval | FieldTypeChange | FieldArgumentTypeChange | EnumValueChange;
+export declare type TypeRemoval = {
+    __typename: 'TypeRemoval';
+    isBreaking: boolean;
+    requestCount: number | null;
+    type: GraphQLTypeDetails;
+};
+export declare type FieldRemoval = {
+    __typename: 'FieldRemoval';
+    isBreaking: boolean;
+    requestCount: number | null;
+    type: GraphQLTypeName;
+    field: {
+        name: string;
+        sdlType: string;
+        args: {
+            name: string;
+            sdlType: string;
+        }[];
+    };
+};
+export declare type FieldArgumentRemoval = {
+    __typename: 'FieldArgumentRemoval';
+    isBreaking: boolean;
+    requestCount: number | null;
+    type: GraphQLTypeName;
+    field: {
+        name: string;
+        sdlType: string;
+        arguments: {
+            name: string;
+            sdlType: string;
+        }[];
+    };
+    node: {
+        name: string;
+        sdlType: string;
+    };
+};
+export declare type FieldTypeChange = {
+    __typename: 'FieldTypeChange';
+    isBreaking: boolean;
+    requestCount: number | null;
+    type: GraphQLTypeName;
+    fieldBefore: {
+        name: string;
+        sdlType: string;
+        args: {
+            name: string;
+            sdlType: string;
+        }[];
+    };
+    fieldAfter: {
+        name: string;
+        sdlType: string;
+    };
+};
+export declare type FieldArgumentTypeChange = {
+    __typename: 'FieldArgumentTypeChange';
+    isBreaking: boolean;
+    requestCount: number | null;
+    type: GraphQLTypeName;
+    field: {
+        name: string;
+        sdlType: string;
+    };
+    fieldArgumentBefore: {
+        name: string;
+        sdlType: string;
+    };
+    fieldArgumentAfter: {
+        name: string;
+        sdlType: string;
+    };
+};
+export declare type EnumValueChange = {
+    __typename: 'EnumValueChange';
+    isBreaking: boolean;
+    requestCount: number | null;
+    enumTypeBefore: {
+        name: string;
+        enumValues: {
+            name: string;
+        }[];
+    };
+    enumTypeAfter: {
+        name: string;
+        enumValues: {
+            name: string;
+        }[];
+    };
+};
+declare type GraphQLTypeName = GraphQLScalarTypeName | GraphQLObjectTypeName | GraphQLInputObjectTypeName | GraphQLEnumTypeName | GraphQLInterfaceTypeName | GraphQLUnionTypeName;
+declare type GraphQLScalarTypeName = {
+    __typename: 'GraphQLScalarType';
+    name: string;
+};
+declare type GraphQLObjectTypeName = {
+    __typename: 'GraphQLObjectType';
+    name: string;
+};
+declare type GraphQLInputObjectTypeName = {
+    __typename: 'GraphQLInputObjectType';
+    name: string;
+};
+declare type GraphQLEnumTypeName = {
+    __typename: 'GraphQLEnumType';
+    name: string;
+};
+declare type GraphQLInterfaceTypeName = {
+    __typename: 'GraphQLInterfaceType';
+    name: string;
+};
+declare type GraphQLUnionTypeName = {
+    __typename: 'GraphQLUnionType';
+    name: string;
+};
+declare type GraphQLTypeDetails = GraphQLScalarTypeDetails | GraphQLObjectTypeDetails | GraphQLInputObjectTypeDetails | GraphQLEnumTypeDetails | GraphQLInterfaceTypeDetails | GraphQLUnionTypeDetails;
+declare type GraphQLScalarTypeDetails = {
+    __typename: 'GraphQLScalarType';
+    name: string;
+};
+declare type GraphQLObjectTypeDetails = {
+    __typename: 'GraphQLObjectType';
+    name: string;
+    fields: {
+        name: string;
+        sdlType: string;
+    }[];
+};
+declare type GraphQLInputObjectTypeDetails = {
+    __typename: 'GraphQLInputObjectType';
+    name: string;
+    fields: {
+        name: string;
+        sdlType: string;
+    }[];
+};
+declare type GraphQLEnumTypeDetails = {
+    __typename: 'GraphQLEnumType';
+    name: string;
+    enumValues: {
+        name: string;
+    }[];
+};
+declare type GraphQLInterfaceTypeDetails = {
+    __typename: 'GraphQLInterfaceType';
+    name: string;
+    fields: {
+        name: string;
+        sdlType: string;
+    }[];
+};
+declare type GraphQLUnionTypeDetails = {
+    __typename: 'GraphQLUnionType';
+    name: string;
+    possibleTypes: {
+        name: string;
+    }[];
+};
+export {};

package/build/helpers/getCodegenSchema.d.ts

@@ -0,0 +1 @@
+export declare function getCodegenSchema(): string | null;

package/build/helpers/searchFreePort.d.ts

@@ -0,0 +1,2 @@
+export declare function isPortFree(port: any): Promise<boolean>;
+export declare function getFirstAvailablePort(port: any): Promise<any>;

package/build/index.d.ts

@@ -0,0 +1,255 @@
+import * as z from 'zod';
+declare const inputSchema: z.ZodObject<{
+    app: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    name: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    originUrl: z.ZodOptional<z.ZodString>;
+    schema: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    injectHeaders: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    enablePlayground: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    ignoreOriginCacheControl: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    queryDepthLimit: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    passThroughOnly: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    mutationPolicy: z.ZodNullable<z.ZodOptional<z.ZodEnum<["Type", "List", "Entity"]>>>;
+    bypassCacheHeaders: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>, "many">>>;
+    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    scopes: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+        definition: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        jwt: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            claim: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            algorithm: z.ZodNullable<z.ZodOptional<z.ZodEnum<["HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "ES256", "PS256", "PS384", "PS512"]>>>;
+            secret: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        }, {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        definition?: string | null | undefined;
+        jwt?: {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        } | null | undefined;
+    }, {
+        definition?: string | null | undefined;
+        jwt?: {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        } | null | undefined;
+    }>]>>>>;
+    rootTypeNames: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        query: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        mutation: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        subscription: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        query?: string | null | undefined;
+        mutation?: string | null | undefined;
+        subscription?: string | null | undefined;
+    }, {
+        query?: string | null | undefined;
+        mutation?: string | null | undefined;
+        subscription?: string | null | undefined;
+    }>>>;
+    keyFields: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        autoAdd: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        defaults: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        types: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        autoAdd?: boolean | null | undefined;
+        defaults?: string[] | null | undefined;
+        types: Record<string, string[]> | null;
+    }, {
+        autoAdd?: boolean | null | undefined;
+        defaults?: string[] | null | undefined;
+        types: Record<string, string[]> | null;
+    }>>>;
+    rules: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Array of types, or dictionary to enable types, fields of types, or list of fields per type. */
+        types: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodBoolean>]>, z.ZodArray<z.ZodString, "many">]>>, z.ZodArray<z.ZodString, "many">]>;
+        maxAge: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        swr: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        scope: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        types: (string[] | Record<string, boolean | Record<string, boolean> | string[]> | undefined) & (string[] | Record<string, boolean | Record<string, boolean> | string[]>);
+        maxAge?: number | null | undefined;
+        swr?: number | null | undefined;
+        scope?: string | null | undefined;
+        description?: string | null | undefined;
+    }, {
+        types: (string[] | Record<string, boolean | Record<string, boolean> | string[]> | undefined) & (string[] | Record<string, boolean | Record<string, boolean> | string[]>);
+        maxAge?: number | null | undefined;
+        swr?: number | null | undefined;
+        scope?: string | null | undefined;
+        description?: string | null | undefined;
+    }>, "many">>>;
+    retries: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        networkErrors: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            isEnabled: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+            whenGraphQLResponse: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        }, {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        }>>>;
+        serverErrors: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+            isEnabled: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+            whenGraphQLResponse: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        }, {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        networkErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+        serverErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+    }, {
+        networkErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+        serverErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    app?: string | undefined;
+    name?: string | undefined;
+    originUrl?: string | undefined;
+    schema?: string | null | undefined;
+    injectHeaders?: boolean | null | undefined;
+    enablePlayground?: boolean | null | undefined;
+    ignoreOriginCacheControl?: boolean | null | undefined;
+    queryDepthLimit?: number | null | undefined;
+    passThroughOnly?: boolean | null | undefined;
+    mutationPolicy?: "Type" | "List" | "Entity" | null | undefined;
+    bypassCacheHeaders?: {
+        name: string;
+    }[] | null | undefined;
+    headers?: Record<string, string> | null | undefined;
+    scopes?: Record<string, string | {
+        definition?: string | null | undefined;
+        jwt?: {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        } | null | undefined;
+    }> | null | undefined;
+    rootTypeNames?: {
+        query?: string | null | undefined;
+        mutation?: string | null | undefined;
+        subscription?: string | null | undefined;
+    } | null | undefined;
+    keyFields?: {
+        autoAdd?: boolean | null | undefined;
+        defaults?: string[] | null | undefined;
+        types: Record<string, string[]> | null;
+    } | null | undefined;
+    rules?: {
+        types: (string[] | Record<string, boolean | Record<string, boolean> | string[]> | undefined) & (string[] | Record<string, boolean | Record<string, boolean> | string[]>);
+        maxAge?: number | null | undefined;
+        swr?: number | null | undefined;
+        scope?: string | null | undefined;
+        description?: string | null | undefined;
+    }[] | null | undefined;
+    retries?: {
+        networkErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+        serverErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+}, {
+    app?: string | undefined;
+    name?: string | undefined;
+    originUrl?: string | undefined;
+    schema?: string | null | undefined;
+    injectHeaders?: boolean | null | undefined;
+    enablePlayground?: boolean | null | undefined;
+    ignoreOriginCacheControl?: boolean | null | undefined;
+    queryDepthLimit?: number | null | undefined;
+    passThroughOnly?: boolean | null | undefined;
+    mutationPolicy?: "Type" | "List" | "Entity" | null | undefined;
+    bypassCacheHeaders?: {
+        name: string;
+    }[] | null | undefined;
+    headers?: Record<string, string> | null | undefined;
+    scopes?: Record<string, string | {
+        definition?: string | null | undefined;
+        jwt?: {
+            claim?: string | null | undefined;
+            algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "PS256" | "PS384" | "PS512" | null | undefined;
+            secret?: string | null | undefined;
+        } | null | undefined;
+    }> | null | undefined;
+    rootTypeNames?: {
+        query?: string | null | undefined;
+        mutation?: string | null | undefined;
+        subscription?: string | null | undefined;
+    } | null | undefined;
+    keyFields?: {
+        autoAdd?: boolean | null | undefined;
+        defaults?: string[] | null | undefined;
+        types: Record<string, string[]> | null;
+    } | null | undefined;
+    rules?: {
+        types: (string[] | Record<string, boolean | Record<string, boolean> | string[]> | undefined) & (string[] | Record<string, boolean | Record<string, boolean> | string[]>);
+        maxAge?: number | null | undefined;
+        swr?: number | null | undefined;
+        scope?: string | null | undefined;
+        description?: string | null | undefined;
+    }[] | null | undefined;
+    retries?: {
+        networkErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+        serverErrors?: {
+            isEnabled?: boolean | null | undefined;
+            whenGraphQLResponse?: boolean | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+}>;
+declare type Input = Readonly<z.infer<typeof inputSchema>>;
+export declare type Config = {
+    config: Input & {
+        name: string;
+        originUrl: string;
+        schema?: string;
+        environments?: {
+            [key: string]: Partial<{
+                name: string;
+                schema?: string;
+                app?: string;
+                originUrl: string;
+            }>;
+        };
+    };
+};
+declare const createConfig: (input: Partial<Input>) => Input;
+export default createConfig;