@coopenomics/factory 2.2.0

package/dist/index.d.ts

@@ -0,0 +1,400 @@
+import { JSONSchemaType } from 'ajv';
+import { Cooperative } from 'cooptypes';
+import { InsertOneResult, Filter, UpdateResult, Document, MongoClient, Db, Collection } from 'mongodb';
+
+declare const registry_id$9 = 1;
+type Action$9 = Cooperative.Registry.WalletAgreement.Action;
+type Model$9 = Cooperative.Registry.WalletAgreement.Model;
+declare const Schema$9: JSONSchemaType<Model$9>;
+declare const Template$9: ITemplate<Model$9>;
+
+declare namespace WalletAgreement {
+  export { type Action$9 as Action, type Model$9 as Model, Schema$9 as Schema, Template$9 as Template, registry_id$9 as registry_id };
+}
+
+declare const registry_id$8 = 2;
+type Action$8 = Cooperative.Registry.RegulationElectronicSignature.Action;
+type Model$8 = Cooperative.Registry.RegulationElectronicSignature.Model;
+declare const Schema$8: JSONSchemaType<Model$8>;
+declare const Template$8: ITemplate<Model$8>;
+
+declare namespace RegulationElectronicSignaturet {
+  export { type Action$8 as Action, type Model$8 as Model, Schema$8 as Schema, Template$8 as Template, registry_id$8 as registry_id };
+}
+
+declare const registry_id$7 = 3;
+type Action$7 = Cooperative.Registry.PrivacyPolicy.Action;
+type Model$7 = Cooperative.Registry.PrivacyPolicy.Model;
+declare const Schema$7: JSONSchemaType<Model$7>;
+declare const Template$7: ITemplate<Model$7>;
+
+declare namespace PrivacyPolicy {
+  export { type Action$7 as Action, type Model$7 as Model, Schema$7 as Schema, Template$7 as Template, registry_id$7 as registry_id };
+}
+
+declare const registry_id$6 = 4;
+type Action$6 = Cooperative.Registry.UserAgreement.Action;
+type Model$6 = Cooperative.Registry.UserAgreement.Model;
+declare const Schema$6: JSONSchemaType<Model$6>;
+declare const Template$6: ITemplate<Model$6>;
+
+declare namespace UserAgreement {
+  export { type Action$6 as Action, type Model$6 as Model, Schema$6 as Schema, Template$6 as Template, registry_id$6 as registry_id };
+}
+
+declare const registry_id$5 = 50;
+type Action$5 = Cooperative.Registry.CoopenomicsAgreement.Action;
+type Model$5 = Cooperative.Registry.CoopenomicsAgreement.Model;
+declare const Schema$5: JSONSchemaType<Model$5>;
+declare const Template$5: ITemplate<Model$5>;
+
+declare namespace CoopenomicsAgreement {
+  export { type Action$5 as Action, type Model$5 as Model, Schema$5 as Schema, Template$5 as Template, registry_id$5 as registry_id };
+}
+
+declare const registry_id$4 = 100;
+/**
+ * Интерфейс генерации заявления на вступление в кооператив
+ */
+type Action$4 = Cooperative.Registry.ParticipantApplication.Action;
+type Model$4 = Cooperative.Registry.ParticipantApplication.Model;
+declare const Schema$4: JSONSchemaType<Model$4>;
+declare const Template$4: ITemplate<Model$4>;
+
+declare namespace ParticipantApplication {
+  export { type Action$4 as Action, type Model$4 as Model, Schema$4 as Schema, Template$4 as Template, registry_id$4 as registry_id };
+}
+
+declare const registry_id$3 = 501;
+/**
+ * Интерфейс генерации решения совета
+ */
+type Action$3 = Cooperative.Registry.DecisionOfParticipantApplication.Action;
+type Model$3 = Cooperative.Registry.DecisionOfParticipantApplication.Model;
+declare const Schema$3: JSONSchemaType<Model$3>;
+declare const Template$3: ITemplate<Model$3>;
+
+declare namespace DecisionOfParticipantApplication {
+  export { type Action$3 as Action, type Model$3 as Model, Schema$3 as Schema, Template$3 as Template, registry_id$3 as registry_id };
+}
+
+declare const registry_id$2 = 101;
+/**
+ * Интерфейс генерации заявления на вступление в кооператив
+ */
+type Action$2 = Cooperative.Registry.SelectBranchStatement.Action;
+type Model$2 = Cooperative.Registry.SelectBranchStatement.Model;
+declare const Schema$2: JSONSchemaType<Model$2>;
+declare const Template$2: ITemplate<Model$2>;
+
+declare namespace SelectBranchStatement {
+  export { type Action$2 as Action, type Model$2 as Model, Schema$2 as Schema, Template$2 as Template, registry_id$2 as registry_id };
+}
+
+declare const registry_id$1 = 599;
+/**
+ * Интерфейс генерации решения совета
+ */
+type Action$1 = Cooperative.Registry.ProjectFreeDecision.Action;
+type Model$1 = Cooperative.Registry.ProjectFreeDecision.Model;
+declare const Schema$1: JSONSchemaType<Model$1>;
+declare const Template$1: ITemplate<Model$1>;
+
+declare namespace ProjectFreeDecision {
+  export { type Action$1 as Action, type Model$1 as Model, Schema$1 as Schema, Template$1 as Template, registry_id$1 as registry_id };
+}
+
+declare const registry_id: 600;
+/**
+ * Интерфейс генерации решения совета
+ */
+type Action = Cooperative.Registry.FreeDecision.Action;
+type Model = Cooperative.Registry.FreeDecision.Model;
+declare const Schema: JSONSchemaType<Model>;
+declare const Template: ITemplate<Model>;
+
+type FreeDecision_Action = Action;
+type FreeDecision_Model = Model;
+declare const FreeDecision_Schema: typeof Schema;
+declare const FreeDecision_Template: typeof Template;
+declare const FreeDecision_registry_id: typeof registry_id;
+declare namespace FreeDecision {
+  export { type FreeDecision_Action as Action, type FreeDecision_Model as Model, FreeDecision_Schema as Schema, FreeDecision_Template as Template, FreeDecision_registry_id as registry_id };
+}
+
+declare const Registry: {
+    1: typeof WalletAgreement;
+    2: typeof RegulationElectronicSignaturet;
+    3: typeof PrivacyPolicy;
+    4: typeof UserAgreement;
+    50: typeof CoopenomicsAgreement;
+    100: typeof ParticipantApplication;
+    101: typeof SelectBranchStatement;
+    501: typeof DecisionOfParticipantApplication;
+    599: typeof ProjectFreeDecision;
+    600: typeof FreeDecision;
+};
+
+interface ValidateResult {
+    valid: boolean;
+    error: string;
+}
+
+type ExternalIndividualData = Cooperative.Users.IIndividualData;
+type InternalIndividualData = ExternalIndividualData;
+declare class Individual {
+    individual?: ExternalIndividualData;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: ExternalIndividualData);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<InternalIndividualData>>;
+    getOne(filter: Filter<InternalIndividualData>): Promise<ExternalIndividualData | null>;
+    getMany(filter: Filter<InternalIndividualData>): Promise<Cooperative.Document.IGetResponse<ExternalIndividualData>>;
+    getHistory(filter: Filter<InternalIndividualData>): Promise<ExternalIndividualData[]>;
+    del(filter: Filter<InternalIndividualData>): Promise<UpdateResult>;
+}
+
+type ExternalOrganizationData = Cooperative.Users.IOrganizationData;
+type InternalOrganizationData = Cooperative.Users.IOrganizationData;
+declare class Organization {
+    db: MongoDBConnector;
+    organization?: ExternalOrganizationData;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: ExternalOrganizationData);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<InternalOrganizationData>>;
+    getOne(filter: Filter<InternalOrganizationData>): Promise<ExternalOrganizationData | null>;
+    getMany(filter: Filter<InternalOrganizationData>): Promise<Cooperative.Document.IGetResponse<ExternalOrganizationData>>;
+    getHistory(filter: Filter<InternalOrganizationData>): Promise<ExternalOrganizationData[]>;
+    del(filter: Filter<InternalOrganizationData>): Promise<UpdateResult>;
+}
+
+type ExternalEntrepreneurData = Cooperative.Users.IEntrepreneurData;
+type InternalEntrepreneurData = Omit<ExternalEntrepreneurData, 'bank_account'> & {
+    bank_account?: Cooperative.Payments.IBankAccount;
+};
+declare class Entrepreneur {
+    db: MongoDBConnector;
+    entrepreneur?: ExternalEntrepreneurData;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: ExternalEntrepreneurData);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<InternalEntrepreneurData>>;
+    getOne(filter: Filter<InternalEntrepreneurData>): Promise<ExternalEntrepreneurData | null>;
+    getMany(filter: Filter<InternalEntrepreneurData>): Promise<Cooperative.Document.IGetResponse<ExternalEntrepreneurData>>;
+    getHistory(filter: Filter<InternalEntrepreneurData>): Promise<ExternalEntrepreneurData[]>;
+    del(filter: Filter<InternalEntrepreneurData>): Promise<UpdateResult>;
+}
+
+type PaymentData = IPaymentData;
+declare class PaymentMethod {
+    db: MongoDBConnector;
+    paymentMethod?: PaymentData;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: PaymentData);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<PaymentData>>;
+    getOne(filter: Filter<PaymentData>): Promise<PaymentData | null>;
+    getMany(filter: Filter<PaymentData>): Promise<Cooperative.Document.IGetResponse<PaymentData>>;
+    getHistory(filter: Filter<PaymentData>): Promise<PaymentData[]>;
+    del(filter: Filter<PaymentData>): Promise<UpdateResult>;
+}
+
+type IVars = Cooperative.Model.IVars;
+declare class Vars {
+    data?: IVars;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: IVars);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<IVars>>;
+    getOne(filter: Filter<IVars>): Promise<IVars | null>;
+    getMany(filter: Filter<IVars>): Promise<Cooperative.Document.IGetResponse<IVars>>;
+    getHistory(filter: Filter<IVars>): Promise<IVars[]>;
+    del(filter: Filter<IVars>): Promise<UpdateResult>;
+}
+
+type ExternalProjectData = Cooperative.Document.IProjectData;
+interface InternalProjectData extends ExternalProjectData {
+    block_num?: number;
+    deleted?: boolean;
+}
+declare class Project {
+    project?: ExternalProjectData;
+    private data_service;
+    constructor(storage: MongoDBConnector, data?: ExternalProjectData);
+    validate(): ValidateResult;
+    save(): Promise<InsertOneResult<InternalProjectData>>;
+    getOne(filter: Filter<InternalProjectData>): Promise<InternalProjectData | null>;
+    getMany(filter: Filter<InternalProjectData>): Promise<Cooperative.Document.IGetResponse<InternalProjectData>>;
+    getHistory(filter: Filter<InternalProjectData>): Promise<InternalProjectData[]>;
+    del(filter: Filter<InternalProjectData>): Promise<UpdateResult>;
+}
+
+type Currency = 'RUB' | 'Other';
+type IBankAccount = Cooperative.Payments.IBankAccount;
+type IPaymentData = Cooperative.Payments.IPaymentData;
+
+interface IFilterDeltas {
+    present: boolean;
+    code: string;
+    scope: string;
+    table: string;
+    primary_key: string;
+    value?: any;
+    block_num: number;
+    block_id: string;
+}
+interface IFilterActions {
+    transaction_id: string;
+    account: string;
+    name: string;
+    authorization: Array<{
+        actor: string;
+        permission: string;
+    }>;
+    data: any;
+}
+interface IBCState {
+    key: string;
+    block_num: number;
+}
+interface IFilterDocuments extends Document, IGeneratedDocument {
+}
+type internalFilterTypes = InternalIndividualData | InternalEntrepreneurData | InternalOrganizationData | IPaymentData | IVars | InternalProjectData;
+type externalDataTypes = ExternalIndividualData | ExternalEntrepreneurData | ExternalOrganizationData | PaymentData | IVars | ExternalProjectData;
+type externalDataTypesArrays = ExternalIndividualData[] | ExternalEntrepreneurData[] | ExternalOrganizationData[] | PaymentData[] | IVars[] | ExternalProjectData[];
+
+declare class MongoDBConnector {
+    client: MongoClient;
+    db: Db;
+    private documents;
+    constructor(uri: string);
+    private extractDbNameFromUri;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getCollection<T extends IDocument>(collectionName: string): Collection<T>;
+    getDocument(filter: Filter<IFilterDocuments>): Promise<IGeneratedDocument>;
+    saveDraft(document: IGeneratedDocument): Promise<void>;
+}
+
+interface IDocument {
+    [key: string]: any;
+}
+
+type CooperativeData = Cooperative.Model.ICooperativeData;
+
+type IMetaDocument = Cooperative.Document.IMetaDocument;
+interface IGeneratedDocument {
+    full_title: string;
+    html: string;
+    hash: string;
+    meta: IMetaDocument;
+    binary: Uint8Array;
+}
+interface NestedRecord {
+    [key: string]: any;
+}
+type ITranslations = Record<string, NestedRecord>;
+interface ITemplate<T> {
+    title: string;
+    description: string;
+    model: JSONSchemaType<T>;
+    context: string;
+    translations: ITranslations;
+}
+interface ICombinedData {
+    individual?: ExternalIndividualData;
+    organization?: ExternalOrganizationData;
+    entrepreneur?: ExternalEntrepreneurData;
+    coop?: CooperativeData;
+    meta: IMetaDocument;
+}
+type Numbers = keyof typeof Registry;
+type LangType = 'ru';
+interface IMetaDocumentPartial extends Partial<IMetaDocument> {
+    username: string;
+    coopname: string;
+    registry_id: number;
+    title: string;
+}
+type IGenerate = Cooperative.Document.IGenerate;
+type IGenerationOptions = Cooperative.Document.IGenerationOptions;
+
+declare const BankAccountSchema: JSONSchemaType<IBankAccount>;
+
+declare const decisionSchema: JSONSchemaType<Cooperative.Document.IDecisionData>;
+
+declare const entrepreneurSchema: JSONSchemaType<ExternalEntrepreneurData>;
+
+declare const organizationSchema: JSONSchemaType<ExternalOrganizationData>;
+
+declare const individualSchema: JSONSchemaType<ExternalIndividualData>;
+
+declare const paymentMethodSchema: JSONSchemaType<IPaymentData>;
+
+declare const CooperativeSchema: JSONSchemaType<CooperativeData>;
+
+declare const VarsSchema: JSONSchemaType<IVars>;
+
+declare abstract class DocFactory<T extends IGenerate> {
+    abstract generateDocument(data: T, options?: IGenerationOptions): Promise<IGeneratedDocument>;
+    storage: MongoDBConnector;
+    constructor(storage: MongoDBConnector);
+    validate(combinedData: ICombinedData, schema: any): Promise<ValidateResult>;
+    getOrganization(username: string, block_num?: number): Promise<ExternalOrganizationData>;
+    getBankAccount(username: string, block_num?: number): Promise<IBankAccount>;
+    getUser(username: string, block_num?: number): Promise<{
+        type: string;
+        data: externalDataTypes;
+    }>;
+    getCooperative(username: string, block_num?: number): Promise<CooperativeData>;
+    getProject(id: string, block_num?: number): Promise<InternalProjectData>;
+    getVars(coopname: string, block_num?: number): Promise<IVars>;
+    getDecision(coop: CooperativeData, coopname: string, decision_id: number, created_at: string): Promise<Cooperative.Document.IDecisionData>;
+    getTemplate<T>(scope: string, registry_id: number, block_num?: number): Promise<ITemplate<T>>;
+    generatePDF(data: externalDataTypes | string, context: string, vars: ICombinedData, translation: ITranslations, meta: IMetaDocument, skip_save?: boolean): Promise<IGeneratedDocument>;
+    getFullName(data: externalDataTypes | string): string;
+    saveDraft(document: IGeneratedDocument): Promise<void>;
+    getMeta<T extends IMetaDocumentPartial>({ title, username, coopname, registry_id, links, lang, generator, version, // TODO перенести в .env
+    created_at, block_num, timezone, // TODO перенести в .env
+    ...restParams }: T): Promise<IMetaDocument>;
+}
+
+type dataTypes = 'individual' | 'entrepreneur' | 'organization' | 'paymentMethod' | 'vars' | 'project';
+
+interface IGenerator {
+    connect: (mongoUri: string) => Promise<void>;
+    disconnect: () => Promise<void>;
+    generate: (data: IGenerate, options?: IGenerationOptions) => Promise<IGeneratedDocument>;
+    getDocument: (filter: Filter<IFilterDocuments>) => Promise<IGeneratedDocument>;
+    constructCooperative: (username: string, block_num?: number) => Promise<CooperativeData | null>;
+    save: ((type: 'individual', data: ExternalIndividualData) => Promise<InsertOneResult>) & ((type: 'entrepreneur', data: ExternalEntrepreneurData) => Promise<InsertOneResult>) & ((type: 'organization', data: ExternalOrganizationData) => Promise<InsertOneResult>) & ((type: 'paymentMethod', data: PaymentData) => Promise<InsertOneResult>) & ((type: 'vars', data: IVars) => Promise<InsertOneResult>) & ((type: 'project', data: ExternalProjectData) => Promise<InsertOneResult>);
+    get: (type: dataTypes, filter: Filter<internalFilterTypes>) => Promise<externalDataTypes | null>;
+    del: (type: dataTypes, filter: Filter<internalFilterTypes>) => Promise<UpdateResult>;
+    list: (type: dataTypes, filter: Filter<internalFilterTypes>) => Promise<Cooperative.Document.IGetResponse<internalFilterTypes>>;
+    getHistory: (type: dataTypes, filter: Filter<internalFilterTypes>) => Promise<externalDataTypesArrays>;
+}
+declare class Generator implements IGenerator {
+    factories: {
+        [K in Numbers]: DocFactory<IGenerate>;
+    };
+    storage: MongoDBConnector;
+    connect(mongoUri: string): Promise<void>;
+    disconnect(): Promise<void>;
+    generate(data: IGenerate, options?: IGenerationOptions): Promise<IGeneratedDocument>;
+    getDocument(filter: Filter<IFilterDocuments>): Promise<IGeneratedDocument>;
+    save(type: 'individual', data: ExternalIndividualData): Promise<InsertOneResult>;
+    save(type: 'entrepreneur', data: ExternalEntrepreneurData): Promise<InsertOneResult>;
+    save(type: 'organization', data: ExternalOrganizationData): Promise<InsertOneResult>;
+    save(type: 'paymentMethod', data: PaymentData): Promise<InsertOneResult>;
+    save(type: 'vars', data: IVars): Promise<InsertOneResult>;
+    save(type: 'project', data: ExternalProjectData): Promise<InsertOneResult>;
+    del(type: dataTypes, filter: Filter<internalFilterTypes>): Promise<UpdateResult>;
+    get(type: dataTypes, filter: Filter<internalFilterTypes>): Promise<externalDataTypes | null>;
+    list(type: dataTypes, filter: Filter<internalFilterTypes>): Promise<Cooperative.Document.IGetResponse<externalDataTypes>>;
+    getHistory(type: 'individual' | 'entrepreneur' | 'organization' | 'paymentMethod' | 'vars' | 'project', filter: Filter<internalFilterTypes>): Promise<externalDataTypesArrays>;
+    getModel(type: dataTypes, data?: externalDataTypes): Individual | Entrepreneur | Organization | PaymentMethod | Vars | Project;
+    constructCooperative(username: string, block_num?: number): Promise<CooperativeData | null>;
+}
+
+export { BankAccountSchema, CoopenomicsAgreement, CooperativeSchema, type Currency, DecisionOfParticipantApplication, FreeDecision, Generator, type IBCState, type IBankAccount, type ICombinedData, type CooperativeData as ICooperativeData, type ExternalEntrepreneurData as IEntrepreneurData, type ExternalProjectData as IExternalProjectData, type IFilterActions, type IFilterDeltas, type IFilterDocuments, type IGenerate, type IGeneratedDocument, type IGenerationOptions, type IGenerator, type ExternalIndividualData as IIndividualData, type IMetaDocument, type IMetaDocumentPartial, type ExternalOrganizationData as IOrganizationData, type IPaymentData, type ITemplate, type ITranslations, type LangType, type NestedRecord, type Numbers, ParticipantApplication, PrivacyPolicy, ProjectFreeDecision, Registry, RegulationElectronicSignaturet as RegulationElectronicSignature, SelectBranchStatement, UserAgreement, VarsSchema, WalletAgreement, type dataTypes, decisionSchema, entrepreneurSchema, type externalDataTypes, type externalDataTypesArrays, individualSchema, type internalFilterTypes, organizationSchema, paymentMethodSchema };