@contember/graphql-client-system 1.2.0-rc.2

package/dist/src/generated/Async.d.ts

@@ -0,0 +1,21 @@
+import type { Fetcher } from "graphql-ts-client-api";
+export declare type GraphQLExecutor = (request: string, variables: object) => Promise<any>;
+export declare function setGraphQLExecutor(executor: GraphQLExecutor): void;
+export declare function execute<TData extends object, TVariables extends object>(fetcher: Fetcher<"Query" | "Mutation", TData, TVariables>, options?: {
+    readonly operationName?: string;
+    readonly variables?: TVariables;
+    readonly executor?: GraphQLExecutor;
+}): Promise<TData>;
+export interface Response<TData> {
+    readonly data?: TData;
+    readonly error?: Error;
+}
+export declare class GraphQLError extends Error {
+    readonly errors: readonly GraphQLSubError[];
+    constructor(errors: any);
+}
+export interface GraphQLSubError {
+    readonly message: string;
+    readonly path: string[];
+}
+//# sourceMappingURL=Async.d.ts.map

package/dist/src/generated/Async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Async.d.ts","sourceRoot":"","sources":["../../../src/generated/Async.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGrD,oBAAY,eAAe,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAEnF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,eAAe,QAE3D;AAED,wBAAsB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,EACzE,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,UAAU,EAAE,KAAK,EAAE,UAAU,CAAC,EACzD,OAAO,CAAC,EAAE;IACN,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAA;CACtC,GACD,OAAO,CAAC,KAAK,CAAC,CAyBjB;AAED,MAAM,WAAW,QAAQ,CAAC,KAAK;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CAC1B;AAED,qBAAa,YAAa,SAAQ,KAAK;IAEnC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;gBAEhC,MAAM,EAAE,GAAG;CAI1B;AAED,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAC1B"}

package/dist/src/generated/Async.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLError = exports.execute = exports.setGraphQLExecutor = void 0;
+const graphql_ts_client_api_1 = require("graphql-ts-client-api");
+function setGraphQLExecutor(executor) {
+    graphQLExecutor = executor;
+}
+exports.setGraphQLExecutor = setGraphQLExecutor;
+async function execute(fetcher, options) {
+    var _a, _b, _c;
+    const executor = (_a = options === null || options === void 0 ? void 0 : options.executor) !== null && _a !== void 0 ? _a : graphQLExecutor;
+    if (executor === undefined) {
+        throw new Error("Executor not set. Call 'setGraphQLExecutor' first or pass executor in options.");
+    }
+    const writer = new graphql_ts_client_api_1.TextWriter();
+    writer.text(`${fetcher.fetchableType.name.toLowerCase()} ${(_b = options === null || options === void 0 ? void 0 : options.operationName) !== null && _b !== void 0 ? _b : ''}`);
+    if (fetcher.variableTypeMap.size !== 0) {
+        writer.scope({ type: "ARGUMENTS", multiLines: fetcher.variableTypeMap.size > 2, suffix: " " }, () => {
+            graphql_ts_client_api_1.util.iterateMap(fetcher.variableTypeMap, ([name, type]) => {
+                writer.seperator();
+                writer.text(`$${name}: ${type}`);
+            });
+        });
+    }
+    writer.text(fetcher.toString());
+    writer.text(fetcher.toFragmentString());
+    const rawResponse = graphql_ts_client_api_1.util.exceptNullValues(await executor(writer.toString(), (_c = options === null || options === void 0 ? void 0 : options.variables) !== null && _c !== void 0 ? _c : {}));
+    if (rawResponse.errors) {
+        throw new GraphQLError(rawResponse.errors);
+    }
+    return rawResponse.data;
+}
+exports.execute = execute;
+class GraphQLError extends Error {
+    constructor(errors) {
+        super();
+        this.errors = errors;
+    }
+}
+exports.GraphQLError = GraphQLError;
+let graphQLExecutor = undefined;
+//# sourceMappingURL=Async.js.map

package/dist/src/generated/Async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Async.js","sourceRoot":"","sources":["../../../src/generated/Async.ts"],"names":[],"mappings":";;;AAEA,iEAAyD;AAIzD,SAAgB,kBAAkB,CAAC,QAAyB;IACxD,eAAe,GAAG,QAAQ,CAAC;AAC/B,CAAC;AAFD,gDAEC;AAEM,KAAK,UAAU,OAAO,CACzB,OAAyD,EACzD,OAIC;;IAGD,MAAM,QAAQ,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,mCAAI,eAAe,CAAC;IACtD,IAAI,QAAQ,KAAK,SAAS,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;KACrG;IAED,MAAM,MAAM,GAAG,IAAI,kCAAU,EAAE,CAAC;IAChC,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,mCAAI,EAAE,EAAE,CAAC,CAAC;IAC3F,IAAI,OAAO,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC,EAAE;QACpC,MAAM,CAAC,KAAK,CAAC,EAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,eAAe,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,EAAC,EAAE,GAAG,EAAE;YAC9F,4BAAI,CAAC,UAAU,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE;gBACtD,MAAM,CAAC,SAAS,EAAE,CAAC;gBACnB,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;KACN;IACD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAChC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAExC,MAAM,WAAW,GAAG,4BAAI,CAAC,gBAAgB,CAAC,MAAM,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,SAAS,mCAAI,EAAE,CAAC,CAAC,CAAC;IACvG,IAAI,WAAW,CAAC,MAAM,EAAE;QACpB,MAAM,IAAI,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;KAC9C;IACD,OAAO,WAAW,CAAC,IAAa,CAAC;AACrC,CAAC;AAhCD,0BAgCC;AAOD,MAAa,YAAa,SAAQ,KAAK;IAInC,YAAY,MAAW;QACnB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;CACJ;AARD,oCAQC;AAOD,IAAI,eAAe,GAAgC,SAAS,CAAC"}

package/dist/src/generated/CommonTypes.d.ts

@@ -0,0 +1,158 @@
+/**
+ *
+ * This 'ImplementationType' is used for inheritance, let's see an example, if graphql schema is:
+ *
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export ImplementationType<T extends string> =
+ *         T extends 'A' ? 'A' | ImplementationType<'B'> :
+ *         T extends 'B' ? 'B' | ImplementationType<'C'> :
+ *         T
+ *     ;
+ *
+ * Let's see another example with abstract type, if the graphql schema is:
+ *
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export ImplementationType<T extends string> =
+ *         T extends 'AbstractType' ? ImplemenationType<'Impl1'> | ImplementationType<'Impl2'> :
+ *         T
+ *     ;
+ */
+export declare type ImplementationType<T> = T extends 'Event' ? 'Event' | ImplementationType<'UpdateEvent'> | ImplementationType<'DeleteEvent'> | ImplementationType<'CreateEvent'> : T;
+/**
+ *
+ * This 'upcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ *
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'B':
+ *                 output.push('B');
+ *                 upcastTypes0('A', output);
+ *                 break;
+ *             case 'C':
+ *                 output.push('C');
+ *                 upcastTypes0('B', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ *
+ * Let's see another example with abstract type, if the graphql schema is:
+ *
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'Impl1':
+ *                 output.push('Impl1');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             case 'Impl2':
+ *                 output.push('Impl2');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ */
+export declare function upcastTypes(typeName: string): string[];
+/**
+ *
+ * This 'downcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ *
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'A':
+ *                 output.push('A');
+ *                 downcastTypes0('B', output);
+ *                 break;
+ *             case 'B':
+ *                 output.push('B');
+ *                 downcastTypes0('C', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ *
+ * Let's see another example with abstract type, if the graphql schema is:
+ *
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'AbstractType':
+ *                 downcastTypes0('Impl1', output);
+ *                 downcastTypes0('Impl2', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ */
+export declare function downcastTypes(typeName: string): string[];
+export declare type WithTypeName<T, TypeName extends string> = T extends {
+    readonly __typename: string;
+} ? T : T & {
+    readonly __typename: TypeName;
+};
+//# sourceMappingURL=CommonTypes.d.ts.map

package/dist/src/generated/CommonTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommonTypes.d.ts","sourceRoot":"","sources":["../../../src/generated/CommonTypes.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oBAAY,kBAAkB,CAAC,CAAC,IAC5B,CAAC,SAAS,OAAO,GAAG,OAAO,GAAG,kBAAkB,CAAC,aAAa,CAAC,GAAG,kBAAkB,CAAC,aAAa,CAAC,GAAG,kBAAkB,CAAC,aAAa,CAAC,GACvI,CAAC,CACJ;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAItD;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAIxD;AAgBD,oBAAY,YAAY,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,IAC/C,CAAC,SAAS;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GACvC,CAAC,GACD,CAAC,GAAG;IAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAA;CAAC,CAAC"}

package/dist/src/generated/CommonTypes.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downcastTypes = exports.upcastTypes = void 0;
+/**
+ *
+ * This 'upcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ *
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'B':
+ *                 output.push('B');
+ *                 upcastTypes0('A', output);
+ *                 break;
+ *             case 'C':
+ *                 output.push('C');
+ *                 upcastTypes0('B', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ *
+ * Let's see another example with abstract type, if the graphql schema is:
+ *
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function upcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         upcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function upcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'Impl1':
+ *                 output.push('Impl1');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             case 'Impl2':
+ *                 output.push('Impl2');
+ *                 upcastTypes0('AbstractType', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ */
+function upcastTypes(typeName) {
+    const typeNames = [];
+    upcastTypes0(typeName, typeNames);
+    return typeNames;
+}
+exports.upcastTypes = upcastTypes;
+function upcastTypes0(typeName, output) {
+    switch (typeName) {
+        case 'UpdateEvent':
+            output.push('UpdateEvent');
+            upcastTypes0('Event', output);
+            break;
+        case 'DeleteEvent':
+            output.push('DeleteEvent');
+            upcastTypes0('Event', output);
+            break;
+        case 'CreateEvent':
+            output.push('CreateEvent');
+            upcastTypes0('Event', output);
+            break;
+        default:
+            output.push(typeName);
+            break;
+    }
+}
+/**
+ *
+ * This 'downcastTypes' is used for inheritance, let's see an example, if graphql schema is:
+ *
+ *     interface A {}
+ *     interface B implements A {}
+ *     type C implements B & A {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'A':
+ *                 output.push('A');
+ *                 downcastTypes0('B', output);
+ *                 break;
+ *             case 'B':
+ *                 output.push('B');
+ *                 downcastTypes0('C', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ *
+ * Let's see another example with abstract type, if the graphql schema is:
+ *
+ *     union AbstractType = Impl1 | Imple2;
+ *     type Impl1 {}
+ *     type Impl2 {}
+ *
+ * Typescript code will be generated by like this:
+ *
+ *     export function downcastTypes(typeName: string): string[] {
+ *         const typeNames: string[] = [];
+ *         downcastTypes0(typeName, typeNames);
+ *         return typeNames;
+ *     }
+ *
+ *     function downcastTypes0(typeName: string, output: string[]) {
+ *         switch (typeName){
+ *             case 'AbstractType':
+ *                 downcastTypes0('Impl1', output);
+ *                 downcastTypes0('Impl2', output);
+ *                 break;
+ *             default:
+ *                 output.push(typeName);
+ *                 break;
+ *         }
+ *     }
+ */
+function downcastTypes(typeName) {
+    const typeNames = [];
+    downcastTypes0(typeName, typeNames);
+    return typeNames;
+}
+exports.downcastTypes = downcastTypes;
+function downcastTypes0(typeName, output) {
+    switch (typeName) {
+        case 'Event':
+            output.push('Event');
+            downcastTypes0('UpdateEvent', output);
+            downcastTypes0('DeleteEvent', output);
+            downcastTypes0('CreateEvent', output);
+            break;
+        default:
+            output.push(typeName);
+            break;
+    }
+}
+;
+//# sourceMappingURL=CommonTypes.js.map

package/dist/src/generated/CommonTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommonTypes.js","sourceRoot":"","sources":["../../../src/generated/CommonTypes.ts"],"names":[],"mappings":";;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,SAAgB,WAAW,CAAC,QAAgB;IACxC,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAClC,OAAO,SAAS,CAAC;AACrB,CAAC;AAJD,kCAIC;AAED,SAAS,YAAY,CAAC,QAAgB,EAAE,MAAgB;IACpD,QAAQ,QAAQ,EAAC;QACb,KAAK,aAAa;YACd,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC3B,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC9B,MAAM;QACV,KAAK,aAAa;YACd,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC3B,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC9B,MAAM;QACV,KAAK,aAAa;YACd,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC3B,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC9B,MAAM;QACV;YACI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtB,MAAM;KACb;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,SAAgB,aAAa,CAAC,QAAgB;IAC1C,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IACpC,OAAO,SAAS,CAAC;AACrB,CAAC;AAJD,sCAIC;AAED,SAAS,cAAc,CAAC,QAAgB,EAAE,MAAgB;IACtD,QAAQ,QAAQ,EAAC;QACb,KAAK,OAAO;YACR,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;YACtC,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;YACtC,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;YACtC,MAAM;QACV;YACI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtB,MAAM;KACb;AACL,CAAC;AAMD,CAAC"}

package/dist/src/generated/EnumInputMetadata.d.ts

@@ -0,0 +1,2 @@
+export declare const ENUM_INPUT_METADATA: import("graphql-ts-client-api").EnumInputMetadata;
+//# sourceMappingURL=EnumInputMetadata.d.ts.map

package/dist/src/generated/EnumInputMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumInputMetadata.d.ts","sourceRoot":"","sources":["../../../src/generated/EnumInputMetadata.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,mBAAmB,mDAAkB,CAAC"}

package/dist/src/generated/EnumInputMetadata.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENUM_INPUT_METADATA = void 0;
+const graphql_ts_client_api_1 = require("graphql-ts-client-api");
+const builder = new graphql_ts_client_api_1.EnumInputMetadataBuilder();
+builder.add("EventType");
+builder.add("EventsFilter", [
+    { name: "types", typeName: "EventType" }
+]);
+builder.add("EventsOrder");
+builder.add("EventsArgs", [
+    { name: "filter", typeName: "EventsFilter" },
+    { name: "order", typeName: "EventsOrder" }
+]);
+builder.add("MigrateErrorCode");
+exports.ENUM_INPUT_METADATA = builder.build();
+//# sourceMappingURL=EnumInputMetadata.js.map

package/dist/src/generated/EnumInputMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumInputMetadata.js","sourceRoot":"","sources":["../../../src/generated/EnumInputMetadata.ts"],"names":[],"mappings":";;;AAAA,iEAAiE;AAEjE,MAAM,OAAO,GAAG,IAAI,gDAAwB,EAAE,CAAC;AAE/C,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAEzB,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE;IACxB,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAC;CACzC,CAAC,CAAC;AAEH,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;AAE3B,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE;IACtB,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAC;IAC1C,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAC;CAC3C,CAAC,CAAC;AAEH,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAEnB,QAAA,mBAAmB,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC"}

package/dist/src/generated/enums/EventType.d.ts

@@ -0,0 +1,2 @@
+export declare type EventType = 'UPDATE' | 'DELETE' | 'CREATE';
+//# sourceMappingURL=EventType.d.ts.map

package/dist/src/generated/enums/EventType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventType.d.ts","sourceRoot":"","sources":["../../../../src/generated/enums/EventType.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC"}

package/dist/src/generated/enums/EventType.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=EventType.js.map

package/dist/src/generated/enums/EventType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventType.js","sourceRoot":"","sources":["../../../../src/generated/enums/EventType.ts"],"names":[],"mappings":""}

package/dist/src/generated/enums/EventsOrder.d.ts

@@ -0,0 +1,2 @@
+export declare type EventsOrder = 'CREATED_AT_ASC' | 'CREATED_AT_DESC' | 'APPLIED_AT_ASC' | 'APPLIED_AT_DESC';
+//# sourceMappingURL=EventsOrder.d.ts.map

package/dist/src/generated/enums/EventsOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventsOrder.d.ts","sourceRoot":"","sources":["../../../../src/generated/enums/EventsOrder.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW,GACnB,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,iBAAiB,CACpB"}

package/dist/src/generated/enums/EventsOrder.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=EventsOrder.js.map

package/dist/src/generated/enums/EventsOrder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventsOrder.js","sourceRoot":"","sources":["../../../../src/generated/enums/EventsOrder.ts"],"names":[],"mappings":""}

package/dist/src/generated/enums/MigrateErrorCode.d.ts

@@ -0,0 +1,2 @@
+export declare type MigrateErrorCode = 'MUST_FOLLOW_LATEST' | 'ALREADY_EXECUTED' | 'INVALID_FORMAT' | 'INVALID_SCHEMA' | 'MIGRATION_FAILED';
+//# sourceMappingURL=MigrateErrorCode.d.ts.map

package/dist/src/generated/enums/MigrateErrorCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateErrorCode.d.ts","sourceRoot":"","sources":["../../../../src/generated/enums/MigrateErrorCode.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB,GACxB,oBAAoB,GACpB,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,kBAAkB,CACrB"}

package/dist/src/generated/enums/MigrateErrorCode.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MigrateErrorCode.js.map

package/dist/src/generated/enums/MigrateErrorCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrateErrorCode.js","sourceRoot":"","sources":["../../../../src/generated/enums/MigrateErrorCode.ts"],"names":[],"mappings":""}

package/dist/src/generated/enums/index.d.ts

@@ -0,0 +1,4 @@
+export type { EventsOrder } from './EventsOrder';
+export type { EventType } from './EventType';
+export type { MigrateErrorCode } from './MigrateErrorCode';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/generated/enums/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/generated/enums/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC"}

package/dist/src/generated/enums/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/src/generated/enums/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/generated/enums/index.ts"],"names":[],"mappings":""}