@restorecommerce/facade 1.2.0 → 1.3.0

package/.eslintignore

@@ -0,0 +1,3 @@
+node_modules
+**/*.d.ts
+**/schema.generated.ts

package/.eslintrc.cjs

@@ -0,0 +1,13 @@
+module.exports = {
+  "root": false,
+  "parserOptions": {
+    "project": [
+      "tsconfig.lib.json",
+      "tsconfig.test.json",
+      "tsconfig.debug.json",
+      "tsconfig.codegen.json",
+      "tsconfig.generate.json"
+    ],
+    "sourceType": "module"
+  }
+};

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.3.0](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.2.0...@restorecommerce/facade@1.3.0) (2023-06-12)
+
+
+### Bug Fixes
+
+* **facade:** move tests to esm ([a580de7](https://github.com/restorecommerce/libs/commit/a580de7b9e3e29c2856d3f4811e47c3fddcc5856))
+
+
+
+
+
 # [1.2.0](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.1.6...@restorecommerce/facade@1.2.0) (2023-06-02)
 
 

package/codegen/index.d.ts

@@ -9,4 +9,4 @@ export interface GenerateSchemaTypingsArgs {
         [key: string]: any;
     };
 }
-export declare function generateSchemaTypings({ schema, outputFile, typescript, typescriptResolvers }: GenerateSchemaTypingsArgs): Promise<void>;
+export declare const generateSchemaTypings: ({ schema, outputFile, typescript, typescriptResolvers }: GenerateSchemaTypingsArgs) => Promise<void>;

package/codegen/index.js

@@ -1,34 +1,17 @@
-"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;
+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.generateSchemaTypings = void 0;
-const fs = __importStar(require("fs"));
-const typescriptPlugin = __importStar(require("@graphql-codegen/typescript"));
-const typescriptResolversPlugin = __importStar(require("@graphql-codegen/typescript-resolvers"));
-const core_1 = require("@graphql-codegen/core");
-async function generateSchemaTypings({ schema, outputFile, typescript, typescriptResolvers }) {
+import * as fs from 'node:fs';
+import * as typescriptPlugin from '@graphql-codegen/typescript';
+import * as typescriptResolversPlugin from '@graphql-codegen/typescript-resolvers';
+import { codegen } from '@graphql-codegen/core';
+export const generateSchemaTypings = ({ schema, outputFile, typescript, typescriptResolvers }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const codegenConfig /* typings wrong?  */ = {
             // used by a plugin internally, although the 'typescript' plugin currently
@@ -38,32 +21,23 @@ async function generateSchemaTypings({ schema, outputFile, typescript, typescrip
             documents: [],
             plugins: [
                 {
-                    typescript: {
-                        maybeValue: 'T | null | undefined',
-                        inputMaybeValue: 'T | null | undefined',
-                        ...(typescript !== null && typescript !== void 0 ? typescript : {})
-                    },
+                    typescript: Object.assign({ maybeValue: 'T | null | undefined', inputMaybeValue: 'T | null | undefined' }, (typescript !== null && typescript !== void 0 ? typescript : {})),
                 },
                 {
-                    typescriptResolvers: {
-                        noSchemaStitching: true,
-                        useIndexSignature: true,
-                        federation: true,
-                        ...(typescriptResolvers !== null && typescriptResolvers !== void 0 ? typescriptResolvers : {})
-                    },
+                    typescriptResolvers: Object.assign({ noSchemaStitching: true, useIndexSignature: true, federation: true }, (typescriptResolvers !== null && typescriptResolvers !== void 0 ? typescriptResolvers : {})),
                 },
             ],
             pluginMap: {
                 typescript: typescriptPlugin,
                 typescriptResolvers: typescriptResolversPlugin,
             },
+            emitLegacyCommonJSImports: false
         };
-        const output = await (0, core_1.codegen)(codegenConfig);
+        const output = yield codegen(codegenConfig);
         fs.writeFileSync(outputFile, output);
         console.log('Schema typings generated in' + outputFile);
     }
     catch (ex) {
         console.error(ex);
     }
-}
-exports.generateSchemaTypings = generateSchemaTypings;
+});

package/debug-run.ts

@@ -15,13 +15,14 @@ import {
   ostorageModule,
   paymentModule,
   schedulingModule
-} from './src';
-import { join } from 'path';
+} from './src/index.js';
+import { join, dirname } from 'node:path';
+import * as url from 'node:url';
 
-const CONFIG_PATH = __dirname;
-const jwks = require('./tests/jwks.json');
+const CONFIG_PATH = dirname(url.fileURLToPath(import.meta.url));
+import jwks from './tests/jwks.json' assert { type: 'json' };
 
-function createTestFacade() {
+const createTestFacade = () => {
   const serviceConfig = createServiceConfig(join(CONFIG_PATH, 'tests'));
 
   const logger = createLogger(serviceConfig.get('logger'));
@@ -66,7 +67,7 @@ function createTestFacade() {
     .useModule(paymentModule({config: serviceConfig.get('payment')}))
     .useModule(schedulingModule({config: serviceConfig.get('scheduling')}))
     .useMiddleware(reqResLogger({logger}));
-}
+};
 
 const facade = createTestFacade();
 

package/dist/gql/index.d.ts

@@ -1 +1 @@
-export * from './types/index';
+export * from './types/index.js';

package/dist/gql/index.js

@@ -1,17 +1 @@
-"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 });
-__exportStar(require("./types/index"), exports);
+export * from './types/index.js';

package/dist/gql/protos/federation.d.ts

@@ -1,6 +1,6 @@
-import { FederatedSchemaWithResolvers, GraphQLResolverMap, ProtoMetadata, ServiceClient, SubSpaceServiceConfig } from './types';
-import { GraphQLSchema } from 'graphql/index';
+import { type FederatedSchemaWithResolvers, type GraphQLResolverMap, type ProtoMetadata, type ServiceClient, type SubSpaceServiceConfig } from './types.js';
+import { type GraphQLSchema } from 'graphql/index.js';
 import { GraphQLObjectType } from 'graphql';
-import { GraphQLList } from 'graphql/type/definition';
+import { GraphQLList } from 'graphql/type/definition.js';
 export declare const buildFederatedSubscriptionSchema: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, schema: GraphQLSchema) => FederatedSchemaWithResolvers;
 export declare const mergeSubscribeIntoSchema: (schema: GraphQLObjectType | GraphQLList<any> | null | undefined, resolvers: GraphQLResolverMap<any>[string]) => void;

package/dist/gql/protos/federation.js

@@ -1,21 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeSubscribeIntoSchema = exports.buildFederatedSubscriptionSchema = void 0;
-const federation_1 = require("@apollo/federation");
-const graphql_tag_1 = __importDefault(require("graphql-tag"));
-const index_1 = require("graphql/index");
-const graphql_1 = require("graphql");
-const definition_1 = require("graphql/type/definition");
-const resolvers_1 = require("./resolvers");
-const buildFederatedSubscriptionSchema = (subServices, config, namespace, schema) => {
-    const resolvers = (0, resolvers_1.generateSubServiceResolvers)(subServices, config, namespace);
+import { buildSubgraphSchema } from '@apollo/federation';
+import { gql } from 'graphql-tag';
+import { printSchema } from 'graphql/index.js';
+import { GraphQLObjectType } from 'graphql';
+import { GraphQLList, GraphQLScalarType } from 'graphql/type/definition.js';
+import { generateSubServiceResolvers } from './resolvers.js';
+export const buildFederatedSubscriptionSchema = (subServices, config, namespace, schema) => {
+    const resolvers = generateSubServiceResolvers(subServices, config, namespace);
     // TODO There is currently no way of building a federated schema from GraphQLSchema Object
     // See https://github.com/apollographql/apollo-server/pull/4310
-    const federatedSchema = (0, federation_1.buildSubgraphSchema)({
-        typeDefs: (0, graphql_tag_1.default)((0, index_1.printSchema)(schema)),
+    const federatedSchema = buildSubgraphSchema({
+        typeDefs: gql(printSchema(schema)),
         resolvers
     });
     return {
@@ -23,14 +17,13 @@ const buildFederatedSubscriptionSchema = (subServices, config, namespace, schema
         resolvers
     };
 };
-exports.buildFederatedSubscriptionSchema = buildFederatedSubscriptionSchema;
-const mergeSubscribeIntoSchema = (schema, resolvers) => {
+export const mergeSubscribeIntoSchema = (schema, resolvers) => {
     if (!schema || !resolvers) {
         return;
     }
     Object.entries(resolvers).forEach(([key, val]) => {
-        if (schema instanceof definition_1.GraphQLList) {
-            (0, exports.mergeSubscribeIntoSchema)(schema.ofType, val);
+        if (schema instanceof GraphQLList) {
+            mergeSubscribeIntoSchema(schema.ofType, val);
             return;
         }
         const field = schema.getFields()[key];
@@ -43,12 +36,11 @@ const mergeSubscribeIntoSchema = (schema, resolvers) => {
             return;
         }
         const fieldType = field.type;
-        if (fieldType instanceof definition_1.GraphQLScalarType) {
+        if (fieldType instanceof GraphQLScalarType) {
             field.subscribe = val['subscribe'];
         }
-        else if (fieldType instanceof graphql_1.GraphQLObjectType) {
-            (0, exports.mergeSubscribeIntoSchema)(fieldType, val);
+        else if (fieldType instanceof GraphQLObjectType) {
+            mergeSubscribeIntoSchema(fieldType, val);
         }
     });
 };
-exports.mergeSubscribeIntoSchema = mergeSubscribeIntoSchema;

package/dist/gql/protos/graphql.d.ts

@@ -1,7 +1,7 @@
-import { GraphQLInputField, GraphQLOutputType } from 'graphql';
-import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInputType } from 'graphql/type/definition';
-import { ProtoMetadata, ServiceConfig } from './types';
-import { ServiceDescriptorProto } from 'ts-proto-descriptors';
+import { type GraphQLInputField, type GraphQLOutputType } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, type GraphQLInputType } from 'graphql/type/definition.js';
+import { type ProtoMetadata, type ServiceConfig } from './types.js';
+import { type ServiceDescriptorProto } from 'ts-proto-descriptors';
 export declare const Mutate: string[];
 export declare const preprocessGQLInput: (data: any, model: GraphQLInputObjectType | GraphQLEnumType | GraphQLInputField | GraphQLInputType) => Promise<any>;
 export declare const postProcessGQLValue: (data: any, model: GraphQLOutputType) => any;

package/dist/gql/protos/graphql.js

@@ -1,14 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWhitelistBlacklistConfig = exports.postProcessGQLValue = exports.preprocessGQLInput = exports.Mutate = void 0;
-const graphql_1 = require("graphql");
-const definition_1 = require("graphql/type/definition");
-exports.Mutate = ['Create', 'Update', 'Upsert'];
-const preprocessGQLInput = async (data, model) => {
-    if (model instanceof definition_1.GraphQLEnumType) {
+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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { GraphQLList, GraphQLNonNull, GraphQLObjectType, } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType, } from 'graphql/type/definition.js';
+export const Mutate = ['Create', 'Update', 'Upsert'];
+export const preprocessGQLInput = (data, model) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    if (model instanceof GraphQLEnumType) {
         return data;
     }
-    if (model instanceof definition_1.GraphQLInputObjectType) {
+    if (model instanceof GraphQLInputObjectType) {
         if (model.name === 'IGoogleProtobufAny') {
             // TODO Use encoded once resource base supports it
             // const typing = getTyping(data.typeUrl);
@@ -18,86 +32,95 @@ const preprocessGQLInput = async (data, model) => {
             //
             // const encoded = typing.processor.encode(typing.processor.fromPartial(data.value)).finish();
             const encoded = Buffer.from(JSON.stringify(data.value));
-            return {
-                ...data,
-                value: encoded
-            };
+            return Object.assign(Object.assign({}, data), { value: encoded });
         }
         else {
             const fields = model.getFields();
             for (let key of Object.keys(fields)) {
                 if (data && key in data) {
-                    data[key] = await (0, exports.preprocessGQLInput)(data[key], fields[key].type);
+                    data[key] = yield preprocessGQLInput(data[key], fields[key].type);
                 }
             }
         }
     }
-    if (model instanceof definition_1.GraphQLScalarType) {
+    if (model instanceof GraphQLScalarType) {
         if (model.name === 'IDateTime') {
             return new Date(data);
         }
     }
-    if (model instanceof graphql_1.GraphQLNonNull) {
-        return await (0, exports.preprocessGQLInput)(data, model.ofType);
+    if (model instanceof GraphQLNonNull) {
+        return yield preprocessGQLInput(data, model.ofType);
     }
-    if (model instanceof graphql_1.GraphQLList) {
+    if (model instanceof GraphQLList) {
         for (let i = 0; i < data.length; i++) {
-            data[i] = await (0, exports.preprocessGQLInput)(data[i], model.ofType);
+            data[i] = yield preprocessGQLInput(data[i], model.ofType);
         }
     }
-    if (model instanceof definition_1.GraphQLScalarType) {
+    if (model instanceof GraphQLScalarType) {
         switch (model.name) {
             case 'Upload':
                 if (typeof data !== 'object') {
                     return Buffer.from(data.toString(), 'utf8');
                 }
-                let fileData = await data;
-                const upload = await fileData.promise;
+                let fileData = yield data;
+                const upload = yield fileData.promise;
                 const stream = upload.createReadStream();
                 const chunks = [];
-                for await (let chunk of stream) {
-                    chunks.push(chunk);
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a;) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        try {
+                            let chunk = _c;
+                            chunks.push(chunk);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
                 return Buffer.concat(chunks);
         }
     }
     return data;
-};
-exports.preprocessGQLInput = preprocessGQLInput;
-const postProcessGQLValue = (data, model) => {
-    if (model instanceof definition_1.GraphQLEnumType) {
+});
+export const postProcessGQLValue = (data, model) => {
+    if (model instanceof GraphQLEnumType) {
         return data;
     }
-    if (model instanceof graphql_1.GraphQLObjectType) {
+    if (model instanceof GraphQLObjectType) {
         if (model.name === 'GoogleProtobufAny' && (data === null || data === void 0 ? void 0 : data.value)) {
             // TODO Use encoded once resource base supports it
             const decoded = JSON.parse(data.value.toString());
-            return {
-                ...data,
-                value: decoded
-            };
+            return Object.assign(Object.assign({}, data), { value: decoded });
         }
         else {
             const fields = model.getFields();
             for (let key of Object.keys(fields)) {
                 if (data && key in data) {
-                    data[key] = (0, exports.postProcessGQLValue)(data[key], fields[key].type);
+                    data[key] = postProcessGQLValue(data[key], fields[key].type);
                 }
             }
         }
     }
-    if (model instanceof graphql_1.GraphQLNonNull) {
-        return (0, exports.postProcessGQLValue)(data, model.ofType);
+    if (model instanceof GraphQLNonNull) {
+        return postProcessGQLValue(data, model.ofType);
     }
-    if (model instanceof graphql_1.GraphQLList) {
+    if (model instanceof GraphQLList) {
         for (let i = 0; i < data.length; i++) {
-            data[i] = (0, exports.postProcessGQLValue)(data[i], model.ofType);
+            data[i] = postProcessGQLValue(data[i], model.ofType);
         }
     }
     return data;
 };
-exports.postProcessGQLValue = postProcessGQLValue;
-const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
+export const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
     var _a, _b, _c, _d;
     const queryList = [];
     if (meta.options && meta.options.services && meta.options.services[metaService.name] && meta.options.services[metaService.name].methods) {
@@ -154,7 +177,7 @@ const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
             }
         }
     }
-    if (exports.Mutate.findIndex(val => mut.has(val)) > -1) {
+    if (Mutate.findIndex(val => mut.has(val)) > -1) {
         mut.add('Mutate');
     }
     return {
@@ -162,4 +185,3 @@ const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
         queries: que
     };
 };
-exports.getWhitelistBlacklistConfig = getWhitelistBlacklistConfig;

package/dist/gql/protos/index.d.ts

@@ -1,6 +1,6 @@
-export * from './types';
-export * from './registry';
-export * from './graphql';
-export * from './federation';
-export * from './resolvers';
-export * from './schema';
+export * from './types.js';
+export * from './registry.js';
+export * from './graphql.js';
+export * from './federation.js';
+export * from './resolvers.js';
+export * from './schema.js';

package/dist/gql/protos/index.js

@@ -1,22 +1,6 @@
-"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 });
-__exportStar(require("./types"), exports);
-__exportStar(require("./registry"), exports);
-__exportStar(require("./graphql"), exports);
-__exportStar(require("./federation"), exports);
-__exportStar(require("./resolvers"), exports);
-__exportStar(require("./schema"), exports);
+export * from './types.js';
+export * from './registry.js';
+export * from './graphql.js';
+export * from './federation.js';
+export * from './resolvers.js';
+export * from './schema.js';

package/dist/gql/protos/registry.d.ts

@@ -1,7 +1,7 @@
-import { GraphQLEnumTypeConfig, GraphQLInputObjectTypeConfig, GraphQLObjectType, GraphQLObjectTypeConfig } from "graphql";
-import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from "graphql/type/definition";
-import { ProtoMetadata, ProtoMetaMessageOptions } from './types';
-import { DescriptorProto, EnumDescriptorProto, MethodDescriptorProto } from "ts-proto-descriptors";
+import { type GraphQLEnumTypeConfig, type GraphQLInputObjectTypeConfig, GraphQLObjectType, type GraphQLObjectTypeConfig } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from 'graphql/type/definition.js';
+import { type ProtoMetadata, type ProtoMetaMessageOptions } from './types.js';
+import { type DescriptorProto, type EnumDescriptorProto, type MethodDescriptorProto } from 'ts-proto-descriptors';
 export interface TypingData {
     output: GraphQLObjectType | GraphQLEnumType | GraphQLScalarType;
     input: GraphQLInputObjectType | GraphQLEnumType | GraphQLScalarType;
@@ -12,12 +12,12 @@ export declare const registeredTypings: Map<string, TypingData>;
 export declare const scalarTypes: string[];
 export declare const IGoogleProtobufAny: GraphQLInputObjectType;
 export declare const clearRegistry: () => void;
-export declare const registerPackagesRecursive: (...protoMetadata: ProtoMetadata[]) => void;
 export declare const getRegisteredEnumTypings: () => string[];
 export declare const getNameSpaceTypeName: (typeName: string) => string | undefined;
+export declare const getTyping: (type: string) => TypingData | undefined;
 export declare const recursiveEnumCheck: (typeName: string, enumMap: Map<string, string>, prevFieldName: string, traversedFields: string[]) => Map<string, string>;
 export declare const registerTyping: (protoPackage: string, message: DescriptorProto, methodDef: MethodDescriptorProto[], opts?: Omit<Readonly<GraphQLObjectTypeConfig<any, any>>, 'fields'>, inputOpts?: Omit<Readonly<GraphQLInputObjectTypeConfig>, 'fields'>, messageOptions?: ProtoMetaMessageOptions) => void;
 export declare const registerEnumTyping: <T = {
     [key: string]: any;
 }>(protoPackage: string, message: EnumDescriptorProto, opts?: Omit<Readonly<GraphQLEnumTypeConfig>, 'values'>) => void;
-export declare const getTyping: (type: string) => TypingData | undefined;
+export declare const registerPackagesRecursive: (...protoMetadata: ProtoMetadata[]) => void;