@coopenomics/sdk 2025.7.23 → 2025.9.1

package/dist/index.d.mts

@@ -1140,6 +1140,21 @@ type ValueTypes = {
         /** Имя аккаунта пользователя */
         username: string | Variable<any, string>;
     };
+    ["ChartOfAccountsItem"]: AliasType<{
+        /** Доступные средства */
+        available?: boolean | `@${string}`;
+        /** Заблокированные средства */
+        blocked?: boolean | `@${string}`;
+        /** Идентификатор счета для отображения (может быть дробным, например "86.6") */
+        displayId?: boolean | `@${string}`;
+        /** Идентификатор счета */
+        id?: boolean | `@${string}`;
+        /** Название счета */
+        name?: boolean | `@${string}`;
+        /** Списанные средства */
+        writeoff?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
     ["CommonRequestInput"]: {
         currency: string | Variable<any, string>;
         hash: string | Variable<any, string>;
@@ -1879,6 +1894,24 @@ type ValueTypes = {
         /** Фильтр по имени */
         name?: string | undefined | null | Variable<any, string>;
     };
+    ["GetLedgerHistoryInput"]: {
+        /** ID счета для фильтрации. Если не указан, возвращаются операции по всем счетам */
+        account_id?: number | undefined | null | Variable<any, string>;
+        /** Имя кооператива */
+        coopname: string | Variable<any, string>;
+        /** Количество записей на странице (по умолчанию 10, максимум 100) */
+        limit?: number | undefined | null | Variable<any, string>;
+        /** Номер страницы (по умолчанию 1) */
+        page?: number | undefined | null | Variable<any, string>;
+        /** Поле для сортировки (created_at, global_sequence) */
+        sortBy?: string | undefined | null | Variable<any, string>;
+        /** Направление сортировки (ASC или DESC) */
+        sortOrder?: string | undefined | null | Variable<any, string>;
+    };
+    ["GetLedgerInput"]: {
+        /** Имя кооператива для получения состояния ledger */
+        coopname: string | Variable<any, string>;
+    };
     ["GetMeetInput"]: {
         /** Имя аккаунта кооператива */
         coopname: string | Variable<any, string>;
@@ -1960,6 +1993,41 @@ type ValueTypes = {
         weight?: boolean | `@${string}`;
         __typename?: boolean | `@${string}`;
     }>;
+    ["LedgerHistoryResponse"]: AliasType<{
+        /** Текущая страница */
+        currentPage?: boolean | `@${string}`;
+        /** Список операций */
+        items?: ValueTypes["LedgerOperation"];
+        /** Общее количество операций */
+        totalCount?: boolean | `@${string}`;
+        /** Общее количество страниц */
+        totalPages?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["LedgerOperation"]: AliasType<{
+        /** ID счета */
+        account_id?: boolean | `@${string}`;
+        /** Тип операции */
+        action?: boolean | `@${string}`;
+        /** Комментарий к операции */
+        comment?: boolean | `@${string}`;
+        /** Имя кооператива */
+        coopname?: boolean | `@${string}`;
+        /** Дата и время создания операции */
+        created_at?: boolean | `@${string}`;
+        /** Номер глобальной последовательности блокчейна */
+        global_sequence?: boolean | `@${string}`;
+        /** Сумма операции */
+        quantity?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["LedgerState"]: AliasType<{
+        /** План счетов с актуальными данными */
+        chartOfAccounts?: ValueTypes["ChartOfAccountsItem"];
+        /** Имя кооператива */
+        coopname?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
     ["LoginInput"]: {
         /** Электронная почта */
         email: string | Variable<any, string>;
@@ -2922,6 +2990,12 @@ type ValueTypes = {
         getExtensions?: [{
             data?: ValueTypes["GetExtensionsInput"] | undefined | null | Variable<any, string>;
         }, ValueTypes["Extension"]];
+        getLedger?: [{
+            data: ValueTypes["GetLedgerInput"] | Variable<any, string>;
+        }, ValueTypes["LedgerState"]];
+        getLedgerHistory?: [{
+            data: ValueTypes["GetLedgerHistoryInput"] | Variable<any, string>;
+        }, ValueTypes["LedgerHistoryResponse"]];
         getMeet?: [{
             data: ValueTypes["GetMeetInput"] | Variable<any, string>;
         }, ValueTypes["MeetAggregate"]];
@@ -4823,6 +4897,21 @@ type ResolverInputTypes = {
         /** Имя аккаунта пользователя */
         username: string;
     };
+    ["ChartOfAccountsItem"]: AliasType<{
+        /** Доступные средства */
+        available?: boolean | `@${string}`;
+        /** Заблокированные средства */
+        blocked?: boolean | `@${string}`;
+        /** Идентификатор счета для отображения (может быть дробным, например "86.6") */
+        displayId?: boolean | `@${string}`;
+        /** Идентификатор счета */
+        id?: boolean | `@${string}`;
+        /** Название счета */
+        name?: boolean | `@${string}`;
+        /** Списанные средства */
+        writeoff?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
     ["CommonRequestInput"]: {
         currency: string;
         hash: string;
@@ -5562,6 +5651,24 @@ type ResolverInputTypes = {
         /** Фильтр по имени */
         name?: string | undefined | null;
     };
+    ["GetLedgerHistoryInput"]: {
+        /** ID счета для фильтрации. Если не указан, возвращаются операции по всем счетам */
+        account_id?: number | undefined | null;
+        /** Имя кооператива */
+        coopname: string;
+        /** Количество записей на странице (по умолчанию 10, максимум 100) */
+        limit?: number | undefined | null;
+        /** Номер страницы (по умолчанию 1) */
+        page?: number | undefined | null;
+        /** Поле для сортировки (created_at, global_sequence) */
+        sortBy?: string | undefined | null;
+        /** Направление сортировки (ASC или DESC) */
+        sortOrder?: string | undefined | null;
+    };
+    ["GetLedgerInput"]: {
+        /** Имя кооператива для получения состояния ledger */
+        coopname: string;
+    };
     ["GetMeetInput"]: {
         /** Имя аккаунта кооператива */
         coopname: string;
@@ -5643,6 +5750,41 @@ type ResolverInputTypes = {
         weight?: boolean | `@${string}`;
         __typename?: boolean | `@${string}`;
     }>;
+    ["LedgerHistoryResponse"]: AliasType<{
+        /** Текущая страница */
+        currentPage?: boolean | `@${string}`;
+        /** Список операций */
+        items?: ResolverInputTypes["LedgerOperation"];
+        /** Общее количество операций */
+        totalCount?: boolean | `@${string}`;
+        /** Общее количество страниц */
+        totalPages?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["LedgerOperation"]: AliasType<{
+        /** ID счета */
+        account_id?: boolean | `@${string}`;
+        /** Тип операции */
+        action?: boolean | `@${string}`;
+        /** Комментарий к операции */
+        comment?: boolean | `@${string}`;
+        /** Имя кооператива */
+        coopname?: boolean | `@${string}`;
+        /** Дата и время создания операции */
+        created_at?: boolean | `@${string}`;
+        /** Номер глобальной последовательности блокчейна */
+        global_sequence?: boolean | `@${string}`;
+        /** Сумма операции */
+        quantity?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["LedgerState"]: AliasType<{
+        /** План счетов с актуальными данными */
+        chartOfAccounts?: ResolverInputTypes["ChartOfAccountsItem"];
+        /** Имя кооператива */
+        coopname?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
     ["LoginInput"]: {
         /** Электронная почта */
         email: string;
@@ -6605,6 +6747,12 @@ type ResolverInputTypes = {
         getExtensions?: [{
             data?: ResolverInputTypes["GetExtensionsInput"] | undefined | null;
         }, ResolverInputTypes["Extension"]];
+        getLedger?: [{
+            data: ResolverInputTypes["GetLedgerInput"];
+        }, ResolverInputTypes["LedgerState"]];
+        getLedgerHistory?: [{
+            data: ResolverInputTypes["GetLedgerHistoryInput"];
+        }, ResolverInputTypes["LedgerHistoryResponse"]];
         getMeet?: [{
             data: ResolverInputTypes["GetMeetInput"];
         }, ResolverInputTypes["MeetAggregate"]];
@@ -8490,6 +8638,20 @@ type ModelTypes = {
         /** Имя аккаунта пользователя */
         username: string;
     };
+    ["ChartOfAccountsItem"]: {
+        /** Доступные средства */
+        available: string;
+        /** Заблокированные средства */
+        blocked: string;
+        /** Идентификатор счета для отображения (может быть дробным, например "86.6") */
+        displayId: string;
+        /** Идентификатор счета */
+        id: number;
+        /** Название счета */
+        name: string;
+        /** Списанные средства */
+        writeoff: string;
+    };
     ["CommonRequestInput"]: {
         currency: string;
         hash: string;
@@ -9209,6 +9371,24 @@ type ModelTypes = {
         /** Фильтр по имени */
         name?: string | undefined | null;
     };
+    ["GetLedgerHistoryInput"]: {
+        /** ID счета для фильтрации. Если не указан, возвращаются операции по всем счетам */
+        account_id?: number | undefined | null;
+        /** Имя кооператива */
+        coopname: string;
+        /** Количество записей на странице (по умолчанию 10, максимум 100) */
+        limit?: number | undefined | null;
+        /** Номер страницы (по умолчанию 1) */
+        page?: number | undefined | null;
+        /** Поле для сортировки (created_at, global_sequence) */
+        sortBy?: string | undefined | null;
+        /** Направление сортировки (ASC или DESC) */
+        sortOrder?: string | undefined | null;
+    };
+    ["GetLedgerInput"]: {
+        /** Имя кооператива для получения состояния ledger */
+        coopname: string;
+    };
     ["GetMeetInput"]: {
         /** Имя аккаунта кооператива */
         coopname: string;
@@ -9287,6 +9467,38 @@ type ModelTypes = {
         /** Вес */
         weight: number;
     };
+    ["LedgerHistoryResponse"]: {
+        /** Текущая страница */
+        currentPage: number;
+        /** Список операций */
+        items: Array<ModelTypes["LedgerOperation"]>;
+        /** Общее количество операций */
+        totalCount: number;
+        /** Общее количество страниц */
+        totalPages: number;
+    };
+    ["LedgerOperation"]: {
+        /** ID счета */
+        account_id: number;
+        /** Тип операции */
+        action: string;
+        /** Комментарий к операции */
+        comment?: string | undefined | null;
+        /** Имя кооператива */
+        coopname: string;
+        /** Дата и время создания операции */
+        created_at: ModelTypes["DateTime"];
+        /** Номер глобальной последовательности блокчейна */
+        global_sequence: number;
+        /** Сумма операции */
+        quantity: string;
+    };
+    ["LedgerState"]: {
+        /** План счетов с актуальными данными */
+        chartOfAccounts: Array<ModelTypes["ChartOfAccountsItem"]>;
+        /** Имя кооператива */
+        coopname: string;
+    };
     ["LoginInput"]: {
         /** Электронная почта */
         email: string;
@@ -10106,6 +10318,10 @@ type ModelTypes = {
         getDocuments: ModelTypes["DocumentsAggregatePaginationResult"];
         /** Получить список расширений */
         getExtensions: Array<ModelTypes["Extension"]>;
+        /** Получить полное состояние плана счетов кооператива. Возвращает все счета из стандартного плана счетов с актуальными данными из блокчейна. Если счет не активен в блокчейне, возвращает нулевые значения. */
+        getLedger: ModelTypes["LedgerState"];
+        /** Получить историю операций по счетам кооператива. Возвращает список операций с возможностью фильтрации по account_id и пагинацией. Операции сортируются по дате создания (новые первыми). */
+        getLedgerHistory: ModelTypes["LedgerHistoryResponse"];
         /** Получить данные собрания по хешу */
         getMeet: ModelTypes["MeetAggregate"];
         /** Получить список всех собраний кооператива */
@@ -11974,6 +12190,21 @@ type GraphQLTypes = {
         /** Имя аккаунта пользователя */
         username: string;
     };
+    ["ChartOfAccountsItem"]: {
+        __typename: "ChartOfAccountsItem";
+        /** Доступные средства */
+        available: string;
+        /** Заблокированные средства */
+        blocked: string;
+        /** Идентификатор счета для отображения (может быть дробным, например "86.6") */
+        displayId: string;
+        /** Идентификатор счета */
+        id: number;
+        /** Название счета */
+        name: string;
+        /** Списанные средства */
+        writeoff: string;
+    };
     ["CommonRequestInput"]: {
         currency: string;
         hash: string;
@@ -12715,6 +12946,24 @@ type GraphQLTypes = {
         /** Фильтр по имени */
         name?: string | undefined | null;
     };
+    ["GetLedgerHistoryInput"]: {
+        /** ID счета для фильтрации. Если не указан, возвращаются операции по всем счетам */
+        account_id?: number | undefined | null;
+        /** Имя кооператива */
+        coopname: string;
+        /** Количество записей на странице (по умолчанию 10, максимум 100) */
+        limit?: number | undefined | null;
+        /** Номер страницы (по умолчанию 1) */
+        page?: number | undefined | null;
+        /** Поле для сортировки (created_at, global_sequence) */
+        sortBy?: string | undefined | null;
+        /** Направление сортировки (ASC или DESC) */
+        sortOrder?: string | undefined | null;
+    };
+    ["GetLedgerInput"]: {
+        /** Имя кооператива для получения состояния ledger */
+        coopname: string;
+    };
     ["GetMeetInput"]: {
         /** Имя аккаунта кооператива */
         coopname: string;
@@ -12800,6 +13049,41 @@ type GraphQLTypes = {
         /** Вес */
         weight: number;
     };
+    ["LedgerHistoryResponse"]: {
+        __typename: "LedgerHistoryResponse";
+        /** Текущая страница */
+        currentPage: number;
+        /** Список операций */
+        items: Array<GraphQLTypes["LedgerOperation"]>;
+        /** Общее количество операций */
+        totalCount: number;
+        /** Общее количество страниц */
+        totalPages: number;
+    };
+    ["LedgerOperation"]: {
+        __typename: "LedgerOperation";
+        /** ID счета */
+        account_id: number;
+        /** Тип операции */
+        action: string;
+        /** Комментарий к операции */
+        comment?: string | undefined | null;
+        /** Имя кооператива */
+        coopname: string;
+        /** Дата и время создания операции */
+        created_at: GraphQLTypes["DateTime"];
+        /** Номер глобальной последовательности блокчейна */
+        global_sequence: number;
+        /** Сумма операции */
+        quantity: string;
+    };
+    ["LedgerState"]: {
+        __typename: "LedgerState";
+        /** План счетов с актуальными данными */
+        chartOfAccounts: Array<GraphQLTypes["ChartOfAccountsItem"]>;
+        /** Имя кооператива */
+        coopname: string;
+    };
     ["LoginInput"]: {
         /** Электронная почта */
         email: string;
@@ -13656,6 +13940,10 @@ type GraphQLTypes = {
         getDocuments: GraphQLTypes["DocumentsAggregatePaginationResult"];
         /** Получить список расширений */
         getExtensions: Array<GraphQLTypes["Extension"]>;
+        /** Получить полное состояние плана счетов кооператива. Возвращает все счета из стандартного плана счетов с актуальными данными из блокчейна. Если счет не активен в блокчейне, возвращает нулевые значения. */
+        getLedger: GraphQLTypes["LedgerState"];
+        /** Получить историю операций по счетам кооператива. Возвращает список операций с возможностью фильтрации по account_id и пагинацией. Операции сортируются по дате создания (новые первыми). */
+        getLedgerHistory: GraphQLTypes["LedgerHistoryResponse"];
         /** Получить данные собрания по хешу */
         getMeet: GraphQLTypes["MeetAggregate"];
         /** Получить список всех собраний кооператива */
@@ -14810,6 +15098,8 @@ type ZEUS_VARIABLES = {
     ["GetBranchesInput"]: ValueTypes["GetBranchesInput"];
     ["GetDocumentsInput"]: ValueTypes["GetDocumentsInput"];
     ["GetExtensionsInput"]: ValueTypes["GetExtensionsInput"];
+    ["GetLedgerHistoryInput"]: ValueTypes["GetLedgerHistoryInput"];
+    ["GetLedgerInput"]: ValueTypes["GetLedgerInput"];
     ["GetMeetInput"]: ValueTypes["GetMeetInput"];
     ["GetMeetsInput"]: ValueTypes["GetMeetsInput"];
     ["GetPaymentMethodsInput"]: ValueTypes["GetPaymentMethodsInput"];
@@ -14891,96 +15181,96 @@ type ZEUS_VARIABLES = {
     ["WebPushSubscriptionKeysInput"]: ValueTypes["WebPushSubscriptionKeysInput"];
 };
 
-declare const index$v_$: typeof $;
-type index$v_AccountType = AccountType;
-declare const index$v_AccountType: typeof AccountType;
-type index$v_AliasType<T> = AliasType<T>;
-type index$v_AllTypesPropsType = AllTypesPropsType;
-declare const index$v_Chain: typeof Chain;
-type index$v_Country = Country;
-declare const index$v_Country: typeof Country;
-type index$v_ExtendedMeetStatus = ExtendedMeetStatus;
-declare const index$v_ExtendedMeetStatus: typeof ExtendedMeetStatus;
-type index$v_ExtractVariables<Query> = ExtractVariables<Query>;
-type index$v_ExtractVariablesDeep<Query> = ExtractVariablesDeep<Query>;
-type index$v_FetchFunction = FetchFunction;
-type index$v_FromSelector<SELECTOR, NAME extends keyof GraphQLTypes, SCLR extends ScalarDefinition = {}> = FromSelector<SELECTOR, NAME, SCLR>;
-declare const index$v_GRAPHQL_TYPE_SEPARATOR: typeof GRAPHQL_TYPE_SEPARATOR;
-type index$v_GenericOperation<O> = GenericOperation<O>;
-type index$v_GetVariableType<T extends string> = GetVariableType<T>;
-declare const index$v_Gql: typeof Gql;
-type index$v_GraphQLError = GraphQLError;
-declare const index$v_GraphQLError: typeof GraphQLError;
-type index$v_GraphQLResponse = GraphQLResponse;
-type index$v_GraphQLTypes = GraphQLTypes;
-type index$v_GraphQLVariableType = GraphQLVariableType;
-declare const index$v_HEADERS: typeof HEADERS;
-declare const index$v_HOST: typeof HOST;
-type index$v_InputType<SRC, DST, SCLR extends ScalarDefinition = {}> = InputType<SRC, DST, SCLR>;
-type index$v_InputValueType = InputValueType;
-declare const index$v_InternalArgsBuilt: typeof InternalArgsBuilt;
-declare const index$v_InternalsBuildQuery: typeof InternalsBuildQuery;
-type index$v_MapType<SRC, DST, SCLR extends ScalarDefinition> = MapType<SRC, DST, SCLR>;
-type index$v_ModelTypes = ModelTypes;
-type index$v_OperationOptions = OperationOptions;
-type index$v_Operations = Operations;
-type index$v_OrganizationType = OrganizationType;
-declare const index$v_OrganizationType: typeof OrganizationType;
-type index$v_PaymentDirection = PaymentDirection;
-declare const index$v_PaymentDirection: typeof PaymentDirection;
-type index$v_PaymentStatus = PaymentStatus;
-declare const index$v_PaymentStatus: typeof PaymentStatus;
-type index$v_PaymentType = PaymentType;
-declare const index$v_PaymentType: typeof PaymentType;
-type index$v_PlainType = PlainType;
-declare const index$v_PrepareScalarPaths: typeof PrepareScalarPaths;
-declare const index$v_ResolveFromPath: typeof ResolveFromPath;
-type index$v_ResolverInputTypes = ResolverInputTypes;
-type index$v_ResolverType<F> = ResolverType<F>;
-type index$v_ReturnTypesType = ReturnTypesType;
-declare const index$v_SEPARATOR: typeof SEPARATOR;
-declare const index$v_START_VAR_NAME: typeof START_VAR_NAME;
-type index$v_ScalarCoder = ScalarCoder;
-type index$v_ScalarCoders = ScalarCoders;
-type index$v_ScalarDefinition = ScalarDefinition;
-type index$v_ScalarResolver = ScalarResolver;
-type index$v_SelectionFunction<V> = SelectionFunction<V>;
-declare const index$v_Selector: typeof Selector;
-declare const index$v_Subscription: typeof Subscription;
-type index$v_SubscriptionFunction = SubscriptionFunction;
-declare const index$v_SubscriptionThunder: typeof SubscriptionThunder;
-type index$v_SubscriptionToGraphQL<Z, T, SCLR extends ScalarDefinition> = SubscriptionToGraphQL<Z, T, SCLR>;
-type index$v_SystemStatus = SystemStatus;
-declare const index$v_SystemStatus: typeof SystemStatus;
-declare const index$v_Thunder: typeof Thunder;
-type index$v_ThunderGraphQLOptions<SCLR extends ScalarDefinition> = ThunderGraphQLOptions<SCLR>;
-declare const index$v_TypeFromSelector: typeof TypeFromSelector;
-type index$v_UnwrapPromise<T> = UnwrapPromise<T>;
-type index$v_UserStatus = UserStatus;
-declare const index$v_UserStatus: typeof UserStatus;
-type index$v_VType = VType;
-type index$v_ValueTypes = ValueTypes;
-type index$v_Variable<T extends GraphQLVariableType, Name extends string> = Variable<T, Name>;
-type index$v_VariableDefinition = VariableDefinition;
-type index$v_WithOptionalNullables<T> = WithOptionalNullables<T>;
-type index$v_WithTypeNameValue<T> = WithTypeNameValue<T>;
-declare const index$v_Zeus: typeof Zeus;
-type index$v_ZeusArgsType = ZeusArgsType;
-type index$v_ZeusHook<T extends (...args: any[]) => Record<string, (...args: any[]) => Promise<any>>, N extends keyof ReturnType<T>> = ZeusHook<T, N>;
-declare const index$v_ZeusScalars: typeof ZeusScalars;
-declare const index$v_ZeusSelect: typeof ZeusSelect;
-type index$v_ZeusState<T extends (...args: any[]) => Promise<any>> = ZeusState<T>;
-declare const index$v_apiFetch: typeof apiFetch;
-declare const index$v_apiSubscription: typeof apiSubscription;
-type index$v_chainOptions = chainOptions;
-declare const index$v_decodeScalarsInResponse: typeof decodeScalarsInResponse;
-type index$v_fetchOptions = fetchOptions;
-declare const index$v_fields: typeof fields;
-declare const index$v_purifyGraphQLKey: typeof purifyGraphQLKey;
-declare const index$v_resolverFor: typeof resolverFor;
-declare const index$v_traverseResponse: typeof traverseResponse;
-declare namespace index$v {
-  export { index$v_$ as $, index$v_AccountType as AccountType, type index$v_AliasType as AliasType, type index$v_AllTypesPropsType as AllTypesPropsType, index$v_Chain as Chain, index$v_Country as Country, index$v_ExtendedMeetStatus as ExtendedMeetStatus, type index$v_ExtractVariables as ExtractVariables, type index$v_ExtractVariablesDeep as ExtractVariablesDeep, type index$v_FetchFunction as FetchFunction, type index$v_FromSelector as FromSelector, index$v_GRAPHQL_TYPE_SEPARATOR as GRAPHQL_TYPE_SEPARATOR, type index$v_GenericOperation as GenericOperation, type index$v_GetVariableType as GetVariableType, index$v_Gql as Gql, index$v_GraphQLError as GraphQLError, type index$v_GraphQLResponse as GraphQLResponse, type index$v_GraphQLTypes as GraphQLTypes, type index$v_GraphQLVariableType as GraphQLVariableType, index$v_HEADERS as HEADERS, index$v_HOST as HOST, type index$v_InputType as InputType, type index$v_InputValueType as InputValueType, index$v_InternalArgsBuilt as InternalArgsBuilt, index$v_InternalsBuildQuery as InternalsBuildQuery, type index$v_MapType as MapType, type index$v_ModelTypes as ModelTypes, type index$v_OperationOptions as OperationOptions, type index$v_Operations as Operations, index$v_OrganizationType as OrganizationType, index$v_PaymentDirection as PaymentDirection, index$v_PaymentStatus as PaymentStatus, index$v_PaymentType as PaymentType, type index$v_PlainType as PlainType, index$v_PrepareScalarPaths as PrepareScalarPaths, index$v_ResolveFromPath as ResolveFromPath, type index$v_ResolverInputTypes as ResolverInputTypes, type index$v_ResolverType as ResolverType, type index$v_ReturnTypesType as ReturnTypesType, index$v_SEPARATOR as SEPARATOR, index$v_START_VAR_NAME as START_VAR_NAME, type index$v_ScalarCoder as ScalarCoder, type index$v_ScalarCoders as ScalarCoders, type index$v_ScalarDefinition as ScalarDefinition, type index$v_ScalarResolver as ScalarResolver, type index$v_SelectionFunction as SelectionFunction, index$v_Selector as Selector, index$v_Subscription as Subscription, type index$v_SubscriptionFunction as SubscriptionFunction, index$v_SubscriptionThunder as SubscriptionThunder, type index$v_SubscriptionToGraphQL as SubscriptionToGraphQL, index$v_SystemStatus as SystemStatus, index$v_Thunder as Thunder, type index$v_ThunderGraphQLOptions as ThunderGraphQLOptions, index$v_TypeFromSelector as TypeFromSelector, type index$v_UnwrapPromise as UnwrapPromise, index$v_UserStatus as UserStatus, type index$v_VType as VType, type index$v_ValueTypes as ValueTypes, type index$v_Variable as Variable, type index$v_VariableDefinition as VariableDefinition, type index$v_WithOptionalNullables as WithOptionalNullables, type index$v_WithTypeNameValue as WithTypeNameValue, index$v_Zeus as Zeus, type index$v_ZeusArgsType as ZeusArgsType, type index$v_ZeusHook as ZeusHook, index$v_ZeusScalars as ZeusScalars, index$v_ZeusSelect as ZeusSelect, type index$v_ZeusState as ZeusState, index$v_apiFetch as apiFetch, index$v_apiSubscription as apiSubscription, type index$v_chainOptions as chainOptions, index$v_decodeScalarsInResponse as decodeScalarsInResponse, type index$v_fetchOptions as fetchOptions, index$v_fields as fields, index$v_purifyGraphQLKey as purifyGraphQLKey, index$v_resolverFor as resolverFor, index$v_traverseResponse as traverseResponse };
+declare const index$w_$: typeof $;
+type index$w_AccountType = AccountType;
+declare const index$w_AccountType: typeof AccountType;
+type index$w_AliasType<T> = AliasType<T>;
+type index$w_AllTypesPropsType = AllTypesPropsType;
+declare const index$w_Chain: typeof Chain;
+type index$w_Country = Country;
+declare const index$w_Country: typeof Country;
+type index$w_ExtendedMeetStatus = ExtendedMeetStatus;
+declare const index$w_ExtendedMeetStatus: typeof ExtendedMeetStatus;
+type index$w_ExtractVariables<Query> = ExtractVariables<Query>;
+type index$w_ExtractVariablesDeep<Query> = ExtractVariablesDeep<Query>;
+type index$w_FetchFunction = FetchFunction;
+type index$w_FromSelector<SELECTOR, NAME extends keyof GraphQLTypes, SCLR extends ScalarDefinition = {}> = FromSelector<SELECTOR, NAME, SCLR>;
+declare const index$w_GRAPHQL_TYPE_SEPARATOR: typeof GRAPHQL_TYPE_SEPARATOR;
+type index$w_GenericOperation<O> = GenericOperation<O>;
+type index$w_GetVariableType<T extends string> = GetVariableType<T>;
+declare const index$w_Gql: typeof Gql;
+type index$w_GraphQLError = GraphQLError;
+declare const index$w_GraphQLError: typeof GraphQLError;
+type index$w_GraphQLResponse = GraphQLResponse;
+type index$w_GraphQLTypes = GraphQLTypes;
+type index$w_GraphQLVariableType = GraphQLVariableType;
+declare const index$w_HEADERS: typeof HEADERS;
+declare const index$w_HOST: typeof HOST;
+type index$w_InputType<SRC, DST, SCLR extends ScalarDefinition = {}> = InputType<SRC, DST, SCLR>;
+type index$w_InputValueType = InputValueType;
+declare const index$w_InternalArgsBuilt: typeof InternalArgsBuilt;
+declare const index$w_InternalsBuildQuery: typeof InternalsBuildQuery;
+type index$w_MapType<SRC, DST, SCLR extends ScalarDefinition> = MapType<SRC, DST, SCLR>;
+type index$w_ModelTypes = ModelTypes;
+type index$w_OperationOptions = OperationOptions;
+type index$w_Operations = Operations;
+type index$w_OrganizationType = OrganizationType;
+declare const index$w_OrganizationType: typeof OrganizationType;
+type index$w_PaymentDirection = PaymentDirection;
+declare const index$w_PaymentDirection: typeof PaymentDirection;
+type index$w_PaymentStatus = PaymentStatus;
+declare const index$w_PaymentStatus: typeof PaymentStatus;
+type index$w_PaymentType = PaymentType;
+declare const index$w_PaymentType: typeof PaymentType;
+type index$w_PlainType = PlainType;
+declare const index$w_PrepareScalarPaths: typeof PrepareScalarPaths;
+declare const index$w_ResolveFromPath: typeof ResolveFromPath;
+type index$w_ResolverInputTypes = ResolverInputTypes;
+type index$w_ResolverType<F> = ResolverType<F>;
+type index$w_ReturnTypesType = ReturnTypesType;
+declare const index$w_SEPARATOR: typeof SEPARATOR;
+declare const index$w_START_VAR_NAME: typeof START_VAR_NAME;
+type index$w_ScalarCoder = ScalarCoder;
+type index$w_ScalarCoders = ScalarCoders;
+type index$w_ScalarDefinition = ScalarDefinition;
+type index$w_ScalarResolver = ScalarResolver;
+type index$w_SelectionFunction<V> = SelectionFunction<V>;
+declare const index$w_Selector: typeof Selector;
+declare const index$w_Subscription: typeof Subscription;
+type index$w_SubscriptionFunction = SubscriptionFunction;
+declare const index$w_SubscriptionThunder: typeof SubscriptionThunder;
+type index$w_SubscriptionToGraphQL<Z, T, SCLR extends ScalarDefinition> = SubscriptionToGraphQL<Z, T, SCLR>;
+type index$w_SystemStatus = SystemStatus;
+declare const index$w_SystemStatus: typeof SystemStatus;
+declare const index$w_Thunder: typeof Thunder;
+type index$w_ThunderGraphQLOptions<SCLR extends ScalarDefinition> = ThunderGraphQLOptions<SCLR>;
+declare const index$w_TypeFromSelector: typeof TypeFromSelector;
+type index$w_UnwrapPromise<T> = UnwrapPromise<T>;
+type index$w_UserStatus = UserStatus;
+declare const index$w_UserStatus: typeof UserStatus;
+type index$w_VType = VType;
+type index$w_ValueTypes = ValueTypes;
+type index$w_Variable<T extends GraphQLVariableType, Name extends string> = Variable<T, Name>;
+type index$w_VariableDefinition = VariableDefinition;
+type index$w_WithOptionalNullables<T> = WithOptionalNullables<T>;
+type index$w_WithTypeNameValue<T> = WithTypeNameValue<T>;
+declare const index$w_Zeus: typeof Zeus;
+type index$w_ZeusArgsType = ZeusArgsType;
+type index$w_ZeusHook<T extends (...args: any[]) => Record<string, (...args: any[]) => Promise<any>>, N extends keyof ReturnType<T>> = ZeusHook<T, N>;
+declare const index$w_ZeusScalars: typeof ZeusScalars;
+declare const index$w_ZeusSelect: typeof ZeusSelect;
+type index$w_ZeusState<T extends (...args: any[]) => Promise<any>> = ZeusState<T>;
+declare const index$w_apiFetch: typeof apiFetch;
+declare const index$w_apiSubscription: typeof apiSubscription;
+type index$w_chainOptions = chainOptions;
+declare const index$w_decodeScalarsInResponse: typeof decodeScalarsInResponse;
+type index$w_fetchOptions = fetchOptions;
+declare const index$w_fields: typeof fields;
+declare const index$w_purifyGraphQLKey: typeof purifyGraphQLKey;
+declare const index$w_resolverFor: typeof resolverFor;
+declare const index$w_traverseResponse: typeof traverseResponse;
+declare namespace index$w {
+  export { index$w_$ as $, index$w_AccountType as AccountType, type index$w_AliasType as AliasType, type index$w_AllTypesPropsType as AllTypesPropsType, index$w_Chain as Chain, index$w_Country as Country, index$w_ExtendedMeetStatus as ExtendedMeetStatus, type index$w_ExtractVariables as ExtractVariables, type index$w_ExtractVariablesDeep as ExtractVariablesDeep, type index$w_FetchFunction as FetchFunction, type index$w_FromSelector as FromSelector, index$w_GRAPHQL_TYPE_SEPARATOR as GRAPHQL_TYPE_SEPARATOR, type index$w_GenericOperation as GenericOperation, type index$w_GetVariableType as GetVariableType, index$w_Gql as Gql, index$w_GraphQLError as GraphQLError, type index$w_GraphQLResponse as GraphQLResponse, type index$w_GraphQLTypes as GraphQLTypes, type index$w_GraphQLVariableType as GraphQLVariableType, index$w_HEADERS as HEADERS, index$w_HOST as HOST, type index$w_InputType as InputType, type index$w_InputValueType as InputValueType, index$w_InternalArgsBuilt as InternalArgsBuilt, index$w_InternalsBuildQuery as InternalsBuildQuery, type index$w_MapType as MapType, type index$w_ModelTypes as ModelTypes, type index$w_OperationOptions as OperationOptions, type index$w_Operations as Operations, index$w_OrganizationType as OrganizationType, index$w_PaymentDirection as PaymentDirection, index$w_PaymentStatus as PaymentStatus, index$w_PaymentType as PaymentType, type index$w_PlainType as PlainType, index$w_PrepareScalarPaths as PrepareScalarPaths, index$w_ResolveFromPath as ResolveFromPath, type index$w_ResolverInputTypes as ResolverInputTypes, type index$w_ResolverType as ResolverType, type index$w_ReturnTypesType as ReturnTypesType, index$w_SEPARATOR as SEPARATOR, index$w_START_VAR_NAME as START_VAR_NAME, type index$w_ScalarCoder as ScalarCoder, type index$w_ScalarCoders as ScalarCoders, type index$w_ScalarDefinition as ScalarDefinition, type index$w_ScalarResolver as ScalarResolver, type index$w_SelectionFunction as SelectionFunction, index$w_Selector as Selector, index$w_Subscription as Subscription, type index$w_SubscriptionFunction as SubscriptionFunction, index$w_SubscriptionThunder as SubscriptionThunder, type index$w_SubscriptionToGraphQL as SubscriptionToGraphQL, index$w_SystemStatus as SystemStatus, index$w_Thunder as Thunder, type index$w_ThunderGraphQLOptions as ThunderGraphQLOptions, index$w_TypeFromSelector as TypeFromSelector, type index$w_UnwrapPromise as UnwrapPromise, index$w_UserStatus as UserStatus, type index$w_VType as VType, type index$w_ValueTypes as ValueTypes, type index$w_Variable as Variable, type index$w_VariableDefinition as VariableDefinition, type index$w_WithOptionalNullables as WithOptionalNullables, type index$w_WithTypeNameValue as WithTypeNameValue, index$w_Zeus as Zeus, type index$w_ZeusArgsType as ZeusArgsType, type index$w_ZeusHook as ZeusHook, index$w_ZeusScalars as ZeusScalars, index$w_ZeusSelect as ZeusSelect, type index$w_ZeusState as ZeusState, index$w_apiFetch as apiFetch, index$w_apiSubscription as apiSubscription, type index$w_chainOptions as chainOptions, index$w_decodeScalarsInResponse as decodeScalarsInResponse, type index$w_fetchOptions as fetchOptions, index$w_fields as fields, index$w_purifyGraphQLKey as purifyGraphQLKey, index$w_resolverFor as resolverFor, index$w_traverseResponse as traverseResponse };
 }
 
 interface ClientConnectionOptions {
@@ -14992,9 +15282,9 @@ interface ClientConnectionOptions {
     username?: string;
 }
 
-type index$u_ClientConnectionOptions = ClientConnectionOptions;
-declare namespace index$u {
-  export type { index$u_ClientConnectionOptions as ClientConnectionOptions };
+type index$v_ClientConnectionOptions = ClientConnectionOptions;
+declare namespace index$v {
+  export type { index$v_ClientConnectionOptions as ClientConnectionOptions };
 }
 
 /**
@@ -15248,15 +15538,15 @@ type ISignedDocumentInput = ModelTypes['SignedDigitalDocumentInput'];
  */
 type ISignedChainDocument = Cooperative.Document.IChainDocument2;
 
-type index$t_IGeneratedDocument<T = any> = IGeneratedDocument<T>;
-type index$t_IMetaDocument = IMetaDocument;
-type index$t_ISignatureInfo = ISignatureInfo;
-type index$t_ISignatureInfoInput = ISignatureInfoInput;
-type index$t_ISignedChainDocument = ISignedChainDocument;
-type index$t_ISignedDocument = ISignedDocument;
-type index$t_ISignedDocumentInput = ISignedDocumentInput;
-declare namespace index$t {
-  export type { index$t_IGeneratedDocument as IGeneratedDocument, index$t_IMetaDocument as IMetaDocument, index$t_ISignatureInfo as ISignatureInfo, index$t_ISignatureInfoInput as ISignatureInfoInput, index$t_ISignedChainDocument as ISignedChainDocument, index$t_ISignedDocument as ISignedDocument, index$t_ISignedDocumentInput as ISignedDocumentInput };
+type index$u_IGeneratedDocument<T = any> = IGeneratedDocument<T>;
+type index$u_IMetaDocument = IMetaDocument;
+type index$u_ISignatureInfo = ISignatureInfo;
+type index$u_ISignatureInfoInput = ISignatureInfoInput;
+type index$u_ISignedChainDocument = ISignedChainDocument;
+type index$u_ISignedDocument = ISignedDocument;
+type index$u_ISignedDocumentInput = ISignedDocumentInput;
+declare namespace index$u {
+  export type { index$u_IGeneratedDocument as IGeneratedDocument, index$u_IMetaDocument as IMetaDocument, index$u_ISignatureInfo as ISignatureInfo, index$u_ISignatureInfoInput as ISignatureInfoInput, index$u_ISignedChainDocument as ISignedChainDocument, index$u_ISignedDocument as ISignedDocument, index$u_ISignedDocumentInput as ISignedDocumentInput };
 }
 
 /**
@@ -15438,7 +15728,7 @@ declare namespace Classes {
   export { Classes_Account as Account, Classes_Blockchain as Blockchain, Classes_Canvas as Canvas, Classes_Crypto as Crypto, Classes_Document as Document, type Classes_IVoteData as IVoteData, Classes_Vote as Vote };
 }
 
-declare const name$1u = "registerAccount";
+declare const name$1w = "registerAccount";
 declare const mutation$1f: {
     registerAccount: [{
         data: Variable<"RegisterAccountInput!", "data">;
@@ -15635,58 +15925,58 @@ declare const mutation$1f: {
         };
     }];
 };
-interface IInput$1v {
+interface IInput$1x {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['RegisterAccountInput'];
 }
-type IOutput$1v = InputType<GraphQLTypes['Mutation'], typeof mutation$1f>;
+type IOutput$1x = InputType<GraphQLTypes['Mutation'], typeof mutation$1f>;
 
 declare namespace registerAccount {
-  export { type IInput$1v as IInput, type IOutput$1v as IOutput, mutation$1f as mutation, name$1u as name };
+  export { type IInput$1x as IInput, type IOutput$1x as IOutput, mutation$1f as mutation, name$1w as name };
 }
 
-declare const name$1t = "resetKey";
+declare const name$1v = "resetKey";
 declare const mutation$1e: {
     resetKey: [{
         data: Variable<"ResetKeyInput!", "data">;
     }, true];
 };
-interface IInput$1u {
+interface IInput$1w {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ResetKeyInput'];
 }
-type IOutput$1u = InputType<GraphQLTypes['Mutation'], typeof mutation$1e>;
+type IOutput$1w = InputType<GraphQLTypes['Mutation'], typeof mutation$1e>;
 
 declare namespace resetKey {
-  export { type IInput$1u as IInput, type IOutput$1u as IOutput, mutation$1e as mutation, name$1t as name };
+  export { type IInput$1w as IInput, type IOutput$1w as IOutput, mutation$1e as mutation, name$1v as name };
 }
 
-declare const name$1s = "startResetKey";
+declare const name$1u = "startResetKey";
 declare const mutation$1d: {
     startResetKey: [{
         data: Variable<"StartResetKeyInput!", "data">;
     }, true];
 };
-interface IInput$1t {
+interface IInput$1v {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['StartResetKeyInput'];
 }
-type IOutput$1t = InputType<GraphQLTypes['Mutation'], typeof mutation$1d>;
+type IOutput$1v = InputType<GraphQLTypes['Mutation'], typeof mutation$1d>;
 
 declare namespace startResetKey {
-  export { type IInput$1t as IInput, type IOutput$1t as IOutput, mutation$1d as mutation, name$1s as name };
+  export { type IInput$1v as IInput, type IOutput$1v as IOutput, mutation$1d as mutation, name$1u as name };
 }
 
-declare const name$1r = "updateAccount";
+declare const name$1t = "updateAccount";
 declare const mutation$1c: {
     updateAccount: [{
         data: Variable<"UpdateAccountInput!", "data">;
@@ -15871,26 +16161,26 @@ declare const mutation$1c: {
         };
     }];
 };
-interface IInput$1s {
+interface IInput$1u {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['UpdateAccountInput'];
 }
-type IOutput$1s = InputType<GraphQLTypes['Mutation'], typeof mutation$1c>;
+type IOutput$1u = InputType<GraphQLTypes['Mutation'], typeof mutation$1c>;
 
 declare namespace updateAccount {
-  export { type IInput$1s as IInput, type IOutput$1s as IOutput, mutation$1c as mutation, name$1r as name };
+  export { type IInput$1u as IInput, type IOutput$1u as IOutput, mutation$1c as mutation, name$1t as name };
 }
 
 /** Зарегистрировать аккаунт пользователя в системе */
 
-declare namespace index$s {
+declare namespace index$t {
   export { registerAccount as RegisterAccount, resetKey as ResetKey, startResetKey as StartResetKey, updateAccount as UpdateAccount };
 }
 
-declare const name$1q = "generatePrivacyAgreement";
+declare const name$1s = "generatePrivacyAgreement";
 declare const mutation$1b: {
     generatePrivacyAgreement: [{
         data: Variable<"GenerateDocumentInput!", "data">;
@@ -15903,7 +16193,7 @@ declare const mutation$1b: {
         meta: boolean;
     }];
 };
-interface IInput$1r {
+interface IInput$1t {
     /**
      * @private
      */
@@ -15911,13 +16201,13 @@ interface IInput$1r {
     data: ModelTypes['GenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$1r = InputType<GraphQLTypes['Mutation'], typeof mutation$1b>;
+type IOutput$1t = InputType<GraphQLTypes['Mutation'], typeof mutation$1b>;
 
 declare namespace generatePrivacyAgreement {
-  export { type IInput$1r as IInput, type IOutput$1r as IOutput, mutation$1b as mutation, name$1q as name };
+  export { type IInput$1t as IInput, type IOutput$1t as IOutput, mutation$1b as mutation, name$1s as name };
 }
 
-declare const name$1p = "generateSignatureAgreement";
+declare const name$1r = "generateSignatureAgreement";
 declare const mutation$1a: {
     generateSignatureAgreement: [{
         data: Variable<"GenerateDocumentInput!", "data">;
@@ -15930,7 +16220,7 @@ declare const mutation$1a: {
         meta: boolean;
     }];
 };
-interface IInput$1q {
+interface IInput$1s {
     /**
      * @private
      */
@@ -15938,13 +16228,13 @@ interface IInput$1q {
     data: ModelTypes['GenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$1q = InputType<GraphQLTypes['Mutation'], typeof mutation$1a>;
+type IOutput$1s = InputType<GraphQLTypes['Mutation'], typeof mutation$1a>;
 
 declare namespace generateSignatureAgreement {
-  export { type IInput$1q as IInput, type IOutput$1q as IOutput, mutation$1a as mutation, name$1p as name };
+  export { type IInput$1s as IInput, type IOutput$1s as IOutput, mutation$1a as mutation, name$1r as name };
 }
 
-declare const name$1o = "generateWalletAgreement";
+declare const name$1q = "generateWalletAgreement";
 declare const mutation$19: {
     generateWalletAgreement: [{
         data: Variable<"GenerateDocumentInput!", "data">;
@@ -15957,7 +16247,7 @@ declare const mutation$19: {
         meta: boolean;
     }];
 };
-interface IInput$1p {
+interface IInput$1r {
     /**
      * @private
      */
@@ -15965,13 +16255,13 @@ interface IInput$1p {
     data: ModelTypes['GenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$1p = InputType<GraphQLTypes['Mutation'], typeof mutation$19>;
+type IOutput$1r = InputType<GraphQLTypes['Mutation'], typeof mutation$19>;
 
 declare namespace generateWalletAgreement {
-  export { type IInput$1p as IInput, type IOutput$1p as IOutput, mutation$19 as mutation, name$1o as name };
+  export { type IInput$1r as IInput, type IOutput$1r as IOutput, mutation$19 as mutation, name$1q as name };
 }
 
-declare const name$1n = "generateUserAgreement";
+declare const name$1p = "generateUserAgreement";
 declare const mutation$18: {
     generateUserAgreement: [{
         data: Variable<"GenerateDocumentInput!", "data">;
@@ -15984,7 +16274,7 @@ declare const mutation$18: {
         meta: boolean;
     }];
 };
-interface IInput$1o {
+interface IInput$1q {
     /**
      * @private
      */
@@ -15992,19 +16282,19 @@ interface IInput$1o {
     data: ModelTypes['GenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$1o = InputType<GraphQLTypes['Mutation'], typeof mutation$18>;
+type IOutput$1q = InputType<GraphQLTypes['Mutation'], typeof mutation$18>;
 
 declare namespace generateUserAgreement {
-  export { type IInput$1o as IInput, type IOutput$1o as IOutput, mutation$18 as mutation, name$1n as name };
+  export { type IInput$1q as IInput, type IOutput$1q as IOutput, mutation$18 as mutation, name$1p as name };
 }
 
 /** Сгенерировать документ согласия с политикой конфиденциальности. */
 
-declare namespace index$r {
+declare namespace index$s {
   export { generatePrivacyAgreement as GeneratePrivacyAgreement, generateSignatureAgreement as GenerateSignatureAgreement, generateUserAgreement as GenerateUserAgreement, generateWalletAgreement as GenerateWalletAgreement };
 }
 
-declare const name$1m = "refresh";
+declare const name$1o = "refresh";
 declare const mutation$17: {
     refresh: [{
         data: Variable<"RefreshInput!", "data">;
@@ -16201,39 +16491,39 @@ declare const mutation$17: {
         };
     }];
 };
-interface IInput$1n {
+interface IInput$1p {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['RefreshInput'];
 }
-type IOutput$1n = InputType<GraphQLTypes['Mutation'], typeof mutation$17>;
+type IOutput$1p = InputType<GraphQLTypes['Mutation'], typeof mutation$17>;
 
 declare namespace refresh {
-  export { type IInput$1n as IInput, type IOutput$1n as IOutput, mutation$17 as mutation, name$1m as name };
+  export { type IInput$1p as IInput, type IOutput$1p as IOutput, mutation$17 as mutation, name$1o as name };
 }
 
-declare const name$1l = "logout";
+declare const name$1n = "logout";
 declare const mutation$16: {
     logout: [{
         data: Variable<"LogoutInput!", "data">;
     }, true];
 };
-interface IInput$1m {
+interface IInput$1o {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['LogoutInput'];
 }
-type IOutput$1m = InputType<GraphQLTypes['Mutation'], typeof mutation$16>;
+type IOutput$1o = InputType<GraphQLTypes['Mutation'], typeof mutation$16>;
 
 declare namespace logout {
-  export { type IInput$1m as IInput, type IOutput$1m as IOutput, mutation$16 as mutation, name$1l as name };
+  export { type IInput$1o as IInput, type IOutput$1o as IOutput, mutation$16 as mutation, name$1n as name };
 }
 
-declare const name$1k = "login";
+declare const name$1m = "login";
 declare const mutation$15: {
     login: [{
         data: Variable<"LoginInput!", "data">;
@@ -16430,26 +16720,26 @@ declare const mutation$15: {
         };
     }];
 };
-interface IInput$1l {
+interface IInput$1n {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['LoginInput'];
 }
-type IOutput$1l = InputType<GraphQLTypes['Mutation'], typeof mutation$15>;
+type IOutput$1n = InputType<GraphQLTypes['Mutation'], typeof mutation$15>;
 
 declare namespace login {
-  export { type IInput$1l as IInput, type IOutput$1l as IOutput, mutation$15 as mutation, name$1k as name };
+  export { type IInput$1n as IInput, type IOutput$1n as IOutput, mutation$15 as mutation, name$1m as name };
 }
 
 /** Обновить токен доступа аккаунта */
 
-declare namespace index$q {
+declare namespace index$r {
   export { login as Login, logout as Logout, refresh as Refresh };
 }
 
-declare const name$1j = "addTrustedAccount";
+declare const name$1l = "addTrustedAccount";
 declare const mutation$14: {
     addTrustedAccount: [{
         data: Variable<"AddTrustedAccountInput!", "data">;
@@ -16532,20 +16822,20 @@ declare const mutation$14: {
         type: boolean;
     }];
 };
-interface IInput$1k {
+interface IInput$1m {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['AddTrustedAccountInput'];
 }
-type IOutput$1k = InputType<GraphQLTypes['Mutation'], typeof mutation$14>;
+type IOutput$1m = InputType<GraphQLTypes['Mutation'], typeof mutation$14>;
 
 declare namespace addTrustedAccount {
-  export { type IInput$1k as IInput, type IOutput$1k as IOutput, mutation$14 as mutation, name$1j as name };
+  export { type IInput$1m as IInput, type IOutput$1m as IOutput, mutation$14 as mutation, name$1l as name };
 }
 
-declare const name$1i = "createBranch";
+declare const name$1k = "createBranch";
 declare const mutation$13: {
     createBranch: [{
         data: Variable<"CreateBranchInput!", "data">;
@@ -16628,39 +16918,39 @@ declare const mutation$13: {
         type: boolean;
     }];
 };
-interface IInput$1j {
+interface IInput$1l {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateBranchInput'];
 }
-type IOutput$1j = InputType<GraphQLTypes['Mutation'], typeof mutation$13>;
+type IOutput$1l = InputType<GraphQLTypes['Mutation'], typeof mutation$13>;
 
 declare namespace createBranch {
-  export { type IInput$1j as IInput, type IOutput$1j as IOutput, mutation$13 as mutation, name$1i as name };
+  export { type IInput$1l as IInput, type IOutput$1l as IOutput, mutation$13 as mutation, name$1k as name };
 }
 
-declare const name$1h = "deleteBranch";
+declare const name$1j = "deleteBranch";
 declare const mutation$12: {
     deleteBranch: [{
         data: Variable<"DeleteBranchInput!", "data">;
     }, true];
 };
-interface IInput$1i {
+interface IInput$1k {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeleteBranchInput'];
 }
-type IOutput$1i = InputType<GraphQLTypes['Mutation'], typeof mutation$12>;
+type IOutput$1k = InputType<GraphQLTypes['Mutation'], typeof mutation$12>;
 
 declare namespace deleteBranch {
-  export { type IInput$1i as IInput, type IOutput$1i as IOutput, mutation$12 as mutation, name$1h as name };
+  export { type IInput$1k as IInput, type IOutput$1k as IOutput, mutation$12 as mutation, name$1j as name };
 }
 
-declare const name$1g = "deleteTrustedAccount";
+declare const name$1i = "deleteTrustedAccount";
 declare const mutation$11: {
     deleteTrustedAccount: [{
         data: Variable<"DeleteTrustedAccountInput!", "data">;
@@ -16743,20 +17033,20 @@ declare const mutation$11: {
         type: boolean;
     }];
 };
-interface IInput$1h {
+interface IInput$1j {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeleteTrustedAccountInput'];
 }
-type IOutput$1h = InputType<GraphQLTypes['Mutation'], typeof mutation$11>;
+type IOutput$1j = InputType<GraphQLTypes['Mutation'], typeof mutation$11>;
 
 declare namespace deleteTrustedAccount {
-  export { type IInput$1h as IInput, type IOutput$1h as IOutput, mutation$11 as mutation, name$1g as name };
+  export { type IInput$1j as IInput, type IOutput$1j as IOutput, mutation$11 as mutation, name$1i as name };
 }
 
-declare const name$1f = "editBranch";
+declare const name$1h = "editBranch";
 declare const mutation$10: {
     editBranch: [{
         data: Variable<"EditBranchInput!", "data">;
@@ -16839,20 +17129,20 @@ declare const mutation$10: {
         type: boolean;
     }];
 };
-interface IInput$1g {
+interface IInput$1i {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['EditBranchInput'];
 }
-type IOutput$1g = InputType<GraphQLTypes['Mutation'], typeof mutation$10>;
+type IOutput$1i = InputType<GraphQLTypes['Mutation'], typeof mutation$10>;
 
 declare namespace editBranch {
-  export { type IInput$1g as IInput, type IOutput$1g as IOutput, mutation$10 as mutation, name$1f as name };
+  export { type IInput$1i as IInput, type IOutput$1i as IOutput, mutation$10 as mutation, name$1h as name };
 }
 
-declare const name$1e = "generateSelectBranchDocument";
+declare const name$1g = "generateSelectBranchDocument";
 declare const mutation$$: {
     generateSelectBranchDocument: [{
         data: Variable<"SelectBranchGenerateDocumentInput!", "data">;
@@ -16865,7 +17155,7 @@ declare const mutation$$: {
         meta: boolean;
     }];
 };
-interface IInput$1f {
+interface IInput$1h {
     /**
      * @private
      */
@@ -16873,38 +17163,38 @@ interface IInput$1f {
     data: ModelTypes['SelectBranchGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$1f = InputType<GraphQLTypes['Mutation'], typeof mutation$$>;
+type IOutput$1h = InputType<GraphQLTypes['Mutation'], typeof mutation$$>;
 
 declare namespace generateSelectBranchDocument {
-  export { type IInput$1f as IInput, type IOutput$1f as IOutput, mutation$$ as mutation, name$1e as name };
+  export { type IInput$1h as IInput, type IOutput$1h as IOutput, mutation$$ as mutation, name$1g as name };
 }
 
-declare const name$1d = "selectBranch";
+declare const name$1f = "selectBranch";
 declare const mutation$_: {
     selectBranch: [{
         data: Variable<"SelectBranchInput!", "data">;
     }, true];
 };
-interface IInput$1e {
+interface IInput$1g {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SelectBranchInput'];
 }
-type IOutput$1e = InputType<GraphQLTypes['Mutation'], typeof mutation$_>;
+type IOutput$1g = InputType<GraphQLTypes['Mutation'], typeof mutation$_>;
 
 declare namespace selectBranch {
-  export { type IInput$1e as IInput, type IOutput$1e as IOutput, mutation$_ as mutation, name$1d as name };
+  export { type IInput$1g as IInput, type IOutput$1g as IOutput, mutation$_ as mutation, name$1f as name };
 }
 
 /** Добавить доверенное лицо кооперативного участка */
 
-declare namespace index$p {
+declare namespace index$q {
   export { addTrustedAccount as AddTrustedAccount, createBranch as CreateBranch, deleteBranch as DeleteBranch, deleteTrustedAccount as DeleteTrustedAccount, editBranch as EditBranch, generateSelectBranchDocument as GenerateSelectBranchDocument, selectBranch as SelectBranch };
 }
 
-declare const name$1c = "acceptChildOrder";
+declare const name$1e = "acceptChildOrder";
 declare const mutation$Z: {
     acceptChildOrder: [{
         data: Variable<"AcceptChildOrderInput!", "data">;
@@ -16920,20 +17210,20 @@ declare const mutation$Z: {
         transaction: boolean;
     }];
 };
-interface IInput$1d {
+interface IInput$1f {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['AcceptChildOrderInput'];
 }
-type IOutput$1d = InputType<GraphQLTypes['Mutation'], typeof mutation$Z>;
+type IOutput$1f = InputType<GraphQLTypes['Mutation'], typeof mutation$Z>;
 
 declare namespace acceptChildOrder {
-  export { type IInput$1d as IInput, type IOutput$1d as IOutput, mutation$Z as mutation, name$1c as name };
+  export { type IInput$1f as IInput, type IOutput$1f as IOutput, mutation$Z as mutation, name$1e as name };
 }
 
-declare const name$1b = "cancelRequest";
+declare const name$1d = "cancelRequest";
 declare const mutation$Y: {
     cancelRequest: [{
         data: Variable<"CancelRequestInput!", "data">;
@@ -16949,20 +17239,20 @@ declare const mutation$Y: {
         transaction: boolean;
     }];
 };
-interface IInput$1c {
+interface IInput$1e {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CancelRequestInput'];
 }
-type IOutput$1c = InputType<GraphQLTypes['Mutation'], typeof mutation$Y>;
+type IOutput$1e = InputType<GraphQLTypes['Mutation'], typeof mutation$Y>;
 
 declare namespace cancelRequest {
-  export { type IInput$1c as IInput, type IOutput$1c as IOutput, mutation$Y as mutation, name$1b as name };
+  export { type IInput$1e as IInput, type IOutput$1e as IOutput, mutation$Y as mutation, name$1d as name };
 }
 
-declare const name$1a = "confirmReceiveOnRequest";
+declare const name$1c = "confirmReceiveOnRequest";
 declare const mutation$X: {
     confirmReceiveOnRequest: [{
         data: Variable<"ConfirmReceiveOnRequestInput!", "data">;
@@ -16978,20 +17268,20 @@ declare const mutation$X: {
         transaction: boolean;
     }];
 };
-interface IInput$1b {
+interface IInput$1d {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ConfirmReceiveOnRequestInput'];
 }
-type IOutput$1b = InputType<GraphQLTypes['Mutation'], typeof mutation$X>;
+type IOutput$1d = InputType<GraphQLTypes['Mutation'], typeof mutation$X>;
 
 declare namespace completeReceiveOnRequest {
-  export { type IInput$1b as IInput, type IOutput$1b as IOutput, mutation$X as mutation, name$1a as name };
+  export { type IInput$1d as IInput, type IOutput$1d as IOutput, mutation$X as mutation, name$1c as name };
 }
 
-declare const name$19 = "completeRequest";
+declare const name$1b = "completeRequest";
 declare const mutation$W: {
     completeRequest: [{
         data: Variable<"CompleteRequestInput!", "data">;
@@ -17007,20 +17297,20 @@ declare const mutation$W: {
         transaction: boolean;
     }];
 };
-interface IInput$1a {
+interface IInput$1c {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CompleteRequestInput'];
 }
-type IOutput$1a = InputType<GraphQLTypes['Mutation'], typeof mutation$W>;
+type IOutput$1c = InputType<GraphQLTypes['Mutation'], typeof mutation$W>;
 
 declare namespace completeRequest {
-  export { type IInput$1a as IInput, type IOutput$1a as IOutput, mutation$W as mutation, name$19 as name };
+  export { type IInput$1c as IInput, type IOutput$1c as IOutput, mutation$W as mutation, name$1b as name };
 }
 
-declare const name$18 = "confirmSupplyOnRequest";
+declare const name$1a = "confirmSupplyOnRequest";
 declare const mutation$V: {
     confirmSupplyOnRequest: [{
         data: Variable<"ConfirmSupplyOnRequestInput!", "data">;
@@ -17036,20 +17326,20 @@ declare const mutation$V: {
         transaction: boolean;
     }];
 };
-interface IInput$19 {
+interface IInput$1b {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ConfirmSupplyOnRequestInput'];
 }
-type IOutput$19 = InputType<GraphQLTypes['Mutation'], typeof mutation$V>;
+type IOutput$1b = InputType<GraphQLTypes['Mutation'], typeof mutation$V>;
 
 declare namespace confirmSupplyOnRequest {
-  export { type IInput$19 as IInput, type IOutput$19 as IOutput, mutation$V as mutation, name$18 as name };
+  export { type IInput$1b as IInput, type IOutput$1b as IOutput, mutation$V as mutation, name$1a as name };
 }
 
-declare const name$17 = "createChildOrder";
+declare const name$19 = "createChildOrder";
 declare const mutation$U: {
     createChildOrder: [{
         data: Variable<"CreateChildOrderInput!", "data">;
@@ -17065,20 +17355,20 @@ declare const mutation$U: {
         transaction: boolean;
     }];
 };
-interface IInput$18 {
+interface IInput$1a {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateChildOrderInput'];
 }
-type IOutput$18 = InputType<GraphQLTypes['Mutation'], typeof mutation$U>;
+type IOutput$1a = InputType<GraphQLTypes['Mutation'], typeof mutation$U>;
 
 declare namespace createChildOrder {
-  export { type IInput$18 as IInput, type IOutput$18 as IOutput, mutation$U as mutation, name$17 as name };
+  export { type IInput$1a as IInput, type IOutput$1a as IOutput, mutation$U as mutation, name$19 as name };
 }
 
-declare const name$16 = "createParentOffer";
+declare const name$18 = "createParentOffer";
 declare const mutation$T: {
     createParentOffer: [{
         data: Variable<"CreateParentOfferInput!", "data">;
@@ -17094,20 +17384,20 @@ declare const mutation$T: {
         transaction: boolean;
     }];
 };
-interface IInput$17 {
+interface IInput$19 {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateParentOfferInput'];
 }
-type IOutput$17 = InputType<GraphQLTypes['Mutation'], typeof mutation$T>;
+type IOutput$19 = InputType<GraphQLTypes['Mutation'], typeof mutation$T>;
 
 declare namespace createParentOffer {
-  export { type IInput$17 as IInput, type IOutput$17 as IOutput, mutation$T as mutation, name$16 as name };
+  export { type IInput$19 as IInput, type IOutput$19 as IOutput, mutation$T as mutation, name$18 as name };
 }
 
-declare const name$15 = "declineRequest";
+declare const name$17 = "declineRequest";
 declare const mutation$S: {
     declineRequest: [{
         data: Variable<"DeclineRequestInput!", "data">;
@@ -17123,20 +17413,20 @@ declare const mutation$S: {
         transaction: boolean;
     }];
 };
-interface IInput$16 {
+interface IInput$18 {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeclineRequestInput'];
 }
-type IOutput$16 = InputType<GraphQLTypes['Mutation'], typeof mutation$S>;
+type IOutput$18 = InputType<GraphQLTypes['Mutation'], typeof mutation$S>;
 
 declare namespace declineRequest {
-  export { type IInput$16 as IInput, type IOutput$16 as IOutput, mutation$S as mutation, name$15 as name };
+  export { type IInput$18 as IInput, type IOutput$18 as IOutput, mutation$S as mutation, name$17 as name };
 }
 
-declare const name$14 = "deliverOnRequest";
+declare const name$16 = "deliverOnRequest";
 declare const mutation$R: {
     deliverOnRequest: [{
         data: Variable<"DeliverOnRequestInput!", "data">;
@@ -17152,20 +17442,20 @@ declare const mutation$R: {
         transaction: boolean;
     }];
 };
-interface IInput$15 {
+interface IInput$17 {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeliverOnRequestInput'];
 }
-type IOutput$15 = InputType<GraphQLTypes['Mutation'], typeof mutation$R>;
+type IOutput$17 = InputType<GraphQLTypes['Mutation'], typeof mutation$R>;
 
 declare namespace deliverOnRequest {
-  export { type IInput$15 as IInput, type IOutput$15 as IOutput, mutation$R as mutation, name$14 as name };
+  export { type IInput$17 as IInput, type IOutput$17 as IOutput, mutation$R as mutation, name$16 as name };
 }
 
-declare const name$13 = "disputeOnRequest";
+declare const name$15 = "disputeOnRequest";
 declare const mutation$Q: {
     disputeOnRequest: [{
         data: Variable<"DisputeOnRequestInput!", "data">;
@@ -17181,20 +17471,20 @@ declare const mutation$Q: {
         transaction: boolean;
     }];
 };
-interface IInput$14 {
+interface IInput$16 {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DisputeOnRequestInput'];
 }
-type IOutput$14 = InputType<GraphQLTypes['Mutation'], typeof mutation$Q>;
+type IOutput$16 = InputType<GraphQLTypes['Mutation'], typeof mutation$Q>;
 
 declare namespace disputeOnRequest {
-  export { type IInput$14 as IInput, type IOutput$14 as IOutput, mutation$Q as mutation, name$13 as name };
+  export { type IInput$16 as IInput, type IOutput$16 as IOutput, mutation$Q as mutation, name$15 as name };
 }
 
-declare const name$12 = "generateAssetContributionAct";
+declare const name$14 = "generateAssetContributionAct";
 declare const mutation$P: {
     generateAssetContributionAct: [{
         data: Variable<"AssetContributionActGenerateDocumentInput!", "data">;
@@ -17207,7 +17497,7 @@ declare const mutation$P: {
         meta: boolean;
     }];
 };
-interface IInput$13 {
+interface IInput$15 {
     /**
      * @private
      */
@@ -17215,13 +17505,13 @@ interface IInput$13 {
     data: ModelTypes['AssetContributionActGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$13 = InputType<GraphQLTypes['Mutation'], typeof mutation$P>;
+type IOutput$15 = InputType<GraphQLTypes['Mutation'], typeof mutation$P>;
 
 declare namespace generateAssetContributionAct {
-  export { type IInput$13 as IInput, type IOutput$13 as IOutput, mutation$P as mutation, name$12 as name };
+  export { type IInput$15 as IInput, type IOutput$15 as IOutput, mutation$P as mutation, name$14 as name };
 }
 
-declare const name$11 = "generateAssetContributionDecision";
+declare const name$13 = "generateAssetContributionDecision";
 declare const mutation$O: {
     generateAssetContributionDecision: [{
         data: Variable<"AssetContributionDecisionGenerateDocumentInput!", "data">;
@@ -17234,7 +17524,7 @@ declare const mutation$O: {
         meta: boolean;
     }];
 };
-interface IInput$12 {
+interface IInput$14 {
     /**
      * @private
      */
@@ -17242,13 +17532,13 @@ interface IInput$12 {
     data: ModelTypes['AssetContributionDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$12 = InputType<GraphQLTypes['Mutation'], typeof mutation$O>;
+type IOutput$14 = InputType<GraphQLTypes['Mutation'], typeof mutation$O>;
 
 declare namespace generateAssetContributionDecision {
-  export { type IInput$12 as IInput, type IOutput$12 as IOutput, mutation$O as mutation, name$11 as name };
+  export { type IInput$14 as IInput, type IOutput$14 as IOutput, mutation$O as mutation, name$13 as name };
 }
 
-declare const name$10 = "generateAssetContributionStatement";
+declare const name$12 = "generateAssetContributionStatement";
 declare const mutation$N: {
     generateAssetContributionStatement: [{
         data: Variable<"AssetContributionStatementGenerateDocumentInput!", "data">;
@@ -17261,7 +17551,7 @@ declare const mutation$N: {
         meta: boolean;
     }];
 };
-interface IInput$11 {
+interface IInput$13 {
     /**
      * @private
      */
@@ -17269,13 +17559,13 @@ interface IInput$11 {
     data: ModelTypes['AssetContributionStatementGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$11 = InputType<GraphQLTypes['Mutation'], typeof mutation$N>;
+type IOutput$13 = InputType<GraphQLTypes['Mutation'], typeof mutation$N>;
 
 declare namespace generateAssetContributionStatement {
-  export { type IInput$11 as IInput, type IOutput$11 as IOutput, mutation$N as mutation, name$10 as name };
+  export { type IInput$13 as IInput, type IOutput$13 as IOutput, mutation$N as mutation, name$12 as name };
 }
 
-declare const name$$ = "generateReturnByAssetAct";
+declare const name$11 = "generateReturnByAssetAct";
 declare const mutation$M: {
     generateReturnByAssetAct: [{
         data: Variable<"ReturnByAssetActGenerateDocumentInput!", "data">;
@@ -17288,7 +17578,7 @@ declare const mutation$M: {
         meta: boolean;
     }];
 };
-interface IInput$10 {
+interface IInput$12 {
     /**
      * @private
      */
@@ -17296,13 +17586,13 @@ interface IInput$10 {
     data: ModelTypes['ReturnByAssetActGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$10 = InputType<GraphQLTypes['Mutation'], typeof mutation$M>;
+type IOutput$12 = InputType<GraphQLTypes['Mutation'], typeof mutation$M>;
 
 declare namespace generateReturnByAssetAct {
-  export { type IInput$10 as IInput, type IOutput$10 as IOutput, mutation$M as mutation, name$$ as name };
+  export { type IInput$12 as IInput, type IOutput$12 as IOutput, mutation$M as mutation, name$11 as name };
 }
 
-declare const name$_ = "generateReturnByAssetDecision";
+declare const name$10 = "generateReturnByAssetDecision";
 declare const mutation$L: {
     generateReturnByAssetDecision: [{
         data: Variable<"ReturnByAssetDecisionGenerateDocumentInput!", "data">;
@@ -17315,7 +17605,7 @@ declare const mutation$L: {
         meta: boolean;
     }];
 };
-interface IInput$$ {
+interface IInput$11 {
     /**
      * @private
      */
@@ -17323,13 +17613,13 @@ interface IInput$$ {
     data: ModelTypes['ReturnByAssetDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$$ = InputType<GraphQLTypes['Mutation'], typeof mutation$L>;
+type IOutput$11 = InputType<GraphQLTypes['Mutation'], typeof mutation$L>;
 
 declare namespace generateReturnByAssetDecision {
-  export { type IInput$$ as IInput, type IOutput$$ as IOutput, mutation$L as mutation, name$_ as name };
+  export { type IInput$11 as IInput, type IOutput$11 as IOutput, mutation$L as mutation, name$10 as name };
 }
 
-declare const name$Z = "generateReturnByAssetStatement";
+declare const name$$ = "generateReturnByAssetStatement";
 declare const mutation$K: {
     generateReturnByAssetStatement: [{
         data: Variable<"ReturnByAssetStatementGenerateDocumentInput!", "data">;
@@ -17342,7 +17632,7 @@ declare const mutation$K: {
         meta: boolean;
     }];
 };
-interface IInput$_ {
+interface IInput$10 {
     /**
      * @private
      */
@@ -17350,13 +17640,13 @@ interface IInput$_ {
     data: ModelTypes['ReturnByAssetStatementGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$_ = InputType<GraphQLTypes['Mutation'], typeof mutation$K>;
+type IOutput$10 = InputType<GraphQLTypes['Mutation'], typeof mutation$K>;
 
 declare namespace generateReturnByAssetStatement {
-  export { type IInput$_ as IInput, type IOutput$_ as IOutput, mutation$K as mutation, name$Z as name };
+  export { type IInput$10 as IInput, type IOutput$10 as IOutput, mutation$K as mutation, name$$ as name };
 }
 
-declare const name$Y = "moderateRequest";
+declare const name$_ = "moderateRequest";
 declare const mutation$J: {
     moderateRequest: [{
         data: Variable<"ModerateRequestInput!", "data">;
@@ -17372,20 +17662,20 @@ declare const mutation$J: {
         transaction: boolean;
     }];
 };
-interface IInput$Z {
+interface IInput$$ {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ModerateRequestInput'];
 }
-type IOutput$Z = InputType<GraphQLTypes['Mutation'], typeof mutation$J>;
+type IOutput$$ = InputType<GraphQLTypes['Mutation'], typeof mutation$J>;
 
 declare namespace moderateRequest {
-  export { type IInput$Z as IInput, type IOutput$Z as IOutput, mutation$J as mutation, name$Y as name };
+  export { type IInput$$ as IInput, type IOutput$$ as IOutput, mutation$J as mutation, name$_ as name };
 }
 
-declare const name$X = "prohibitRequest";
+declare const name$Z = "prohibitRequest";
 declare const mutation$I: {
     prohibitRequest: [{
         data: Variable<"ProhibitRequestInput!", "data">;
@@ -17401,20 +17691,20 @@ declare const mutation$I: {
         transaction: boolean;
     }];
 };
-interface IInput$Y {
+interface IInput$_ {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ProhibitRequestInput'];
 }
-type IOutput$Y = InputType<GraphQLTypes['Mutation'], typeof mutation$I>;
+type IOutput$_ = InputType<GraphQLTypes['Mutation'], typeof mutation$I>;
 
 declare namespace prohibitRequest {
-  export { type IInput$Y as IInput, type IOutput$Y as IOutput, mutation$I as mutation, name$X as name };
+  export { type IInput$_ as IInput, type IOutput$_ as IOutput, mutation$I as mutation, name$Z as name };
 }
 
-declare const name$W = "publishRequest";
+declare const name$Y = "publishRequest";
 declare const mutation$H: {
     publishRequest: [{
         data: Variable<"PublishRequestInput!", "data">;
@@ -17430,20 +17720,20 @@ declare const mutation$H: {
         transaction: boolean;
     }];
 };
-interface IInput$X {
+interface IInput$Z {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['PublishRequestInput'];
 }
-type IOutput$X = InputType<GraphQLTypes['Mutation'], typeof mutation$H>;
+type IOutput$Z = InputType<GraphQLTypes['Mutation'], typeof mutation$H>;
 
 declare namespace publishRequest {
-  export { type IInput$X as IInput, type IOutput$X as IOutput, mutation$H as mutation, name$W as name };
+  export { type IInput$Z as IInput, type IOutput$Z as IOutput, mutation$H as mutation, name$Y as name };
 }
 
-declare const name$V = "receiveOnRequest";
+declare const name$X = "receiveOnRequest";
 declare const mutation$G: {
     receiveOnRequest: [{
         data: Variable<"ReceiveOnRequestInput!", "data">;
@@ -17459,20 +17749,20 @@ declare const mutation$G: {
         transaction: boolean;
     }];
 };
-interface IInput$W {
+interface IInput$Y {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ReceiveOnRequestInput'];
 }
-type IOutput$W = InputType<GraphQLTypes['Mutation'], typeof mutation$G>;
+type IOutput$Y = InputType<GraphQLTypes['Mutation'], typeof mutation$G>;
 
 declare namespace receiveOnRequest {
-  export { type IInput$W as IInput, type IOutput$W as IOutput, mutation$G as mutation, name$V as name };
+  export { type IInput$Y as IInput, type IOutput$Y as IOutput, mutation$G as mutation, name$X as name };
 }
 
-declare const name$U = "supplyOnRequest";
+declare const name$W = "supplyOnRequest";
 declare const mutation$F: {
     supplyOnRequest: [{
         data: Variable<"SupplyOnRequestInput!", "data">;
@@ -17488,20 +17778,20 @@ declare const mutation$F: {
         transaction: boolean;
     }];
 };
-interface IInput$V {
+interface IInput$X {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SupplyOnRequestInput'];
 }
-type IOutput$V = InputType<GraphQLTypes['Mutation'], typeof mutation$F>;
+type IOutput$X = InputType<GraphQLTypes['Mutation'], typeof mutation$F>;
 
 declare namespace supplyOnRequest {
-  export { type IInput$V as IInput, type IOutput$V as IOutput, mutation$F as mutation, name$U as name };
+  export { type IInput$X as IInput, type IOutput$X as IOutput, mutation$F as mutation, name$W as name };
 }
 
-declare const name$T = "unpublishRequest";
+declare const name$V = "unpublishRequest";
 declare const mutation$E: {
     unpublishRequest: [{
         data: Variable<"UnpublishRequestInput!", "data">;
@@ -17517,20 +17807,20 @@ declare const mutation$E: {
         transaction: boolean;
     }];
 };
-interface IInput$U {
+interface IInput$W {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['UnpublishRequestInput'];
 }
-type IOutput$U = InputType<GraphQLTypes['Mutation'], typeof mutation$E>;
+type IOutput$W = InputType<GraphQLTypes['Mutation'], typeof mutation$E>;
 
 declare namespace unpublishRequest {
-  export { type IInput$U as IInput, type IOutput$U as IOutput, mutation$E as mutation, name$T as name };
+  export { type IInput$W as IInput, type IOutput$W as IOutput, mutation$E as mutation, name$V as name };
 }
 
-declare const name$S = "updateRequest";
+declare const name$U = "updateRequest";
 declare const mutation$D: {
     updateRequest: [{
         data: Variable<"UpdateRequestInput!", "data">;
@@ -17546,26 +17836,26 @@ declare const mutation$D: {
         transaction: boolean;
     }];
 };
-interface IInput$T {
+interface IInput$V {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['UpdateRequestInput'];
 }
-type IOutput$T = InputType<GraphQLTypes['Mutation'], typeof mutation$D>;
+type IOutput$V = InputType<GraphQLTypes['Mutation'], typeof mutation$D>;
 
 declare namespace updateRequest {
-  export { type IInput$T as IInput, type IOutput$T as IOutput, mutation$D as mutation, name$S as name };
+  export { type IInput$V as IInput, type IOutput$V as IOutput, mutation$D as mutation, name$U as name };
 }
 
 /** Подтвердить поставку имущества на заявку */
 
-declare namespace index$o {
+declare namespace index$p {
   export { acceptChildOrder as AcceptChildOrder, cancelRequest as CancelRequest, completeReceiveOnRequest as CompleteReceiveOnRequest, completeRequest as CompleteRequest, confirmSupplyOnRequest as ConfirmSupplyOnRequest, createChildOrder as CreateChildOrder, createParentOffer as CreateParentOffer, declineRequest as DeclineRequest, deliverOnRequest as DeliverOnRequest, disputeOnRequest as DisputeOnRequest, generateAssetContributionAct as GenerateAssetContributionAct, generateAssetContributionDecision as GenerateAssetContributionDecision, generateAssetContributionStatement as GenerateAssetContributionStatement, generateReturnByAssetAct as GenerateReturnByAssetAct, generateReturnByAssetDecision as GenerateReturnByAssetDecision, generateReturnByAssetStatement as GenerateReturnByAssetStatement, moderateRequest as ModerateRequest, prohibitRequest as ProhibitRequest, publishRequest as PublishRequest, receiveOnRequest as ReceiveOnRequest, supplyOnRequest as SupplyOnRequest, unpublishRequest as UnpublishRequest, updateRequest as UpdateRequest };
 }
 
-declare const name$R = "installExtension";
+declare const name$T = "installExtension";
 declare const mutation$C: {
     installExtension: [{
         data: Variable<"ExtensionInput!", "data">;
@@ -17590,39 +17880,39 @@ declare const mutation$C: {
         instructions: boolean;
     }];
 };
-interface IInput$S {
+interface IInput$U {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ExtensionInput'];
 }
-type IOutput$S = InputType<GraphQLTypes['Mutation'], typeof mutation$C>;
+type IOutput$U = InputType<GraphQLTypes['Mutation'], typeof mutation$C>;
 
 declare namespace installExtension {
-  export { type IInput$S as IInput, type IOutput$S as IOutput, mutation$C as mutation, name$R as name };
+  export { type IInput$U as IInput, type IOutput$U as IOutput, mutation$C as mutation, name$T as name };
 }
 
-declare const name$Q = "uninstallExtension";
+declare const name$S = "uninstallExtension";
 declare const mutation$B: {
     uninstallExtension: [{
         data: Variable<"UninstallExtensionInput!", "data">;
     }, true];
 };
-interface IInput$R {
+interface IInput$T {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['UninstallExtensionInput'];
 }
-type IOutput$R = InputType<GraphQLTypes['Mutation'], typeof mutation$B>;
+type IOutput$T = InputType<GraphQLTypes['Mutation'], typeof mutation$B>;
 
 declare namespace uninstallExtension {
-  export { type IInput$R as IInput, type IOutput$R as IOutput, mutation$B as mutation, name$Q as name };
+  export { type IInput$T as IInput, type IOutput$T as IOutput, mutation$B as mutation, name$S as name };
 }
 
-declare const name$P = "updateExtension";
+declare const name$R = "updateExtension";
 declare const mutation$A: {
     updateExtension: [{
         data: Variable<"ExtensionInput!", "data">;
@@ -17647,26 +17937,26 @@ declare const mutation$A: {
         instructions: boolean;
     }];
 };
-interface IInput$Q {
+interface IInput$S {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['ExtensionInput'];
 }
-type IOutput$Q = InputType<GraphQLTypes['Mutation'], typeof mutation$A>;
+type IOutput$S = InputType<GraphQLTypes['Mutation'], typeof mutation$A>;
 
 declare namespace updateExtension {
-  export { type IInput$Q as IInput, type IOutput$Q as IOutput, mutation$A as mutation, name$P as name };
+  export { type IInput$S as IInput, type IOutput$S as IOutput, mutation$A as mutation, name$R as name };
 }
 
 /** Установить расширение */
 
-declare namespace index$n {
+declare namespace index$o {
   export { installExtension as InstallExtension, uninstallExtension as UninstallExtension, updateExtension as UpdateExtension };
 }
 
-declare const name$O = "generateProjectOfFreeDecision";
+declare const name$Q = "generateProjectOfFreeDecision";
 declare const mutation$z: {
     generateProjectOfFreeDecision: [{
         data: Variable<"ProjectFreeDecisionGenerateDocumentInput!", "data">;
@@ -17679,7 +17969,7 @@ declare const mutation$z: {
         meta: boolean;
     }];
 };
-interface IInput$P {
+interface IInput$R {
     /**
      * @private
      */
@@ -17687,13 +17977,13 @@ interface IInput$P {
     data: ModelTypes['ProjectFreeDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$P = InputType<GraphQLTypes['Mutation'], typeof mutation$z>;
+type IOutput$R = InputType<GraphQLTypes['Mutation'], typeof mutation$z>;
 
 declare namespace generateProjectOfFreeDecisionDocument {
-  export { type IInput$P as IInput, type IOutput$P as IOutput, mutation$z as mutation, name$O as name };
+  export { type IInput$R as IInput, type IOutput$R as IOutput, mutation$z as mutation, name$Q as name };
 }
 
-declare const name$N = "generateFreeDecision";
+declare const name$P = "generateFreeDecision";
 declare const mutation$y: {
     generateFreeDecision: [{
         data: Variable<"FreeDecisionGenerateDocumentInput!", "data">;
@@ -17706,7 +17996,7 @@ declare const mutation$y: {
         meta: boolean;
     }];
 };
-interface IInput$O {
+interface IInput$Q {
     /**
      * @private
      */
@@ -17714,32 +18004,32 @@ interface IInput$O {
     data: ModelTypes['FreeDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$O = InputType<GraphQLTypes['Mutation'], typeof mutation$y>;
+type IOutput$Q = InputType<GraphQLTypes['Mutation'], typeof mutation$y>;
 
 declare namespace generateFreeDecision {
-  export { type IInput$O as IInput, type IOutput$O as IOutput, mutation$y as mutation, name$N as name };
+  export { type IInput$Q as IInput, type IOutput$Q as IOutput, mutation$y as mutation, name$P as name };
 }
 
-declare const name$M = "publishProjectOfFreeDecision";
+declare const name$O = "publishProjectOfFreeDecision";
 declare const mutation$x: {
     publishProjectOfFreeDecision: [{
         data: Variable<"PublishProjectFreeDecisionInput!", "data">;
     }, true];
 };
-interface IInput$N {
+interface IInput$P {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['PublishProjectFreeDecisionInput'];
 }
-type IOutput$N = InputType<GraphQLTypes['Mutation'], typeof mutation$x>;
+type IOutput$P = InputType<GraphQLTypes['Mutation'], typeof mutation$x>;
 
 declare namespace publishProjectOfFreeDecision {
-  export { type IInput$N as IInput, type IOutput$N as IOutput, mutation$x as mutation, name$M as name };
+  export { type IInput$P as IInput, type IOutput$P as IOutput, mutation$x as mutation, name$O as name };
 }
 
-declare const name$L = "createProjectOfFreeDecision";
+declare const name$N = "createProjectOfFreeDecision";
 declare const mutation$w: {
     createProjectOfFreeDecision: [{
         data: Variable<"CreateProjectFreeDecisionInput!", "data">;
@@ -17749,26 +18039,26 @@ declare const mutation$w: {
         question: boolean;
     }];
 };
-interface IInput$M {
+interface IInput$O {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateProjectFreeDecisionInput'];
 }
-type IOutput$M = InputType<GraphQLTypes['Mutation'], typeof mutation$w>;
+type IOutput$O = InputType<GraphQLTypes['Mutation'], typeof mutation$w>;
 
 declare namespace createProjectOfFreeDecision {
-  export { type IInput$M as IInput, type IOutput$M as IOutput, mutation$w as mutation, name$L as name };
+  export { type IInput$O as IInput, type IOutput$O as IOutput, mutation$w as mutation, name$N as name };
 }
 
 /** Сгенерировать документ проекта свободного решения */
 
-declare namespace index$m {
+declare namespace index$n {
   export { createProjectOfFreeDecision as CreateProjectOfFreeDecision, generateFreeDecision as GenerateFreeDecision, generateProjectOfFreeDecisionDocument as GenerateProjectOfFreeDecision, publishProjectOfFreeDecision as PublishProjectOfFreeDecision };
 }
 
-declare const name$K = "setPaymentStatus";
+declare const name$M = "setPaymentStatus";
 declare const mutation$v: {
     setPaymentStatus: [{
         data: Variable<"SetPaymentStatusInput!", "data">;
@@ -17840,18 +18130,18 @@ declare const mutation$v: {
         is_final: boolean;
     }];
 };
-interface IInput$L {
+interface IInput$N {
     data: ModelTypes['SetPaymentStatusInput'];
 }
-type IOutput$L = {
-    [name$K]: ModelTypes['GatewayPayment'];
+type IOutput$N = {
+    [name$M]: ModelTypes['GatewayPayment'];
 };
 
 declare namespace updatePaymentStatus {
-  export { type IInput$L as IInput, type IOutput$L as IOutput, mutation$v as mutation, name$K as name };
+  export { type IInput$N as IInput, type IOutput$N as IOutput, mutation$v as mutation, name$M as name };
 }
 
-declare const name$J = "createInitialPayment";
+declare const name$L = "createInitialPayment";
 declare const mutation$u: {
     createInitialPayment: [{
         data: Variable<"CreateInitialPaymentInput!", "data">;
@@ -17923,16 +18213,16 @@ declare const mutation$u: {
         is_final: boolean;
     }];
 };
-interface IInput$K {
+interface IInput$M {
     data: ModelTypes['CreateInitialPaymentInput'];
 }
-type IOutput$K = InputType<GraphQLTypes['Mutation'], typeof mutation$u>;
+type IOutput$M = InputType<GraphQLTypes['Mutation'], typeof mutation$u>;
 
 declare namespace createInitialPayment$1 {
-  export { type IInput$K as IInput, type IOutput$K as IOutput, mutation$u as mutation, name$J as name };
+  export { type IInput$M as IInput, type IOutput$M as IOutput, mutation$u as mutation, name$L as name };
 }
 
-declare const name$I = "createDepositPayment";
+declare const name$K = "createDepositPayment";
 declare const mutation$t: {
     createDepositPayment: [{
         data: Variable<"CreateDepositPaymentInput!", "data">;
@@ -18004,22 +18294,22 @@ declare const mutation$t: {
         is_final: boolean;
     }];
 };
-interface IInput$J {
+interface IInput$L {
     data: ModelTypes['CreateDepositPaymentInput'];
 }
-type IOutput$J = InputType<GraphQLTypes['Mutation'], typeof mutation$t>;
+type IOutput$L = InputType<GraphQLTypes['Mutation'], typeof mutation$t>;
 
 declare namespace createDepositPayment$1 {
-  export { type IInput$J as IInput, type IOutput$J as IOutput, mutation$t as mutation, name$I as name };
+  export { type IInput$L as IInput, type IOutput$L as IOutput, mutation$t as mutation, name$K as name };
 }
 
 /** Управление статусом платежа осущствляется мутацией setPaymentStatus. При переходе платежа в статус PAID вызывается эффект в блокчейне, который завершает операцию автоматическим переводом платежа в статус COMPLETED. При установке статуса REFUNDED запускается процесс отмены платежа в блокчейне. Остальные статусы не приводят к эффектам в блокчейне. */
 
-declare namespace index$l {
+declare namespace index$m {
   export { createDepositPayment$1 as CreateDepositPayment, createInitialPayment$1 as CreateInitialPayment, updatePaymentStatus as SetPaymentStatus };
 }
 
-declare const name$H = "createAnnualGeneralMeet";
+declare const name$J = "createAnnualGeneralMeet";
 /**
  * Сгенерировать документ предложения повестки очередного общего собрания пайщиков
  */
@@ -18733,20 +19023,20 @@ declare const mutation$s: {
         };
     }];
 };
-interface IInput$I {
+interface IInput$K {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateAnnualGeneralMeetInput'];
 }
-type IOutput$I = InputType<GraphQLTypes['Mutation'], typeof mutation$s>;
+type IOutput$K = InputType<GraphQLTypes['Mutation'], typeof mutation$s>;
 
 declare namespace createAnnualGeneralMeet {
-  export { type IInput$I as IInput, type IOutput$I as IOutput, mutation$s as mutation, name$H as name };
+  export { type IInput$K as IInput, type IOutput$K as IOutput, mutation$s as mutation, name$J as name };
 }
 
-declare const name$G = "generateAnnualGeneralMeetAgendaDocument";
+declare const name$I = "generateAnnualGeneralMeetAgendaDocument";
 /**
  * Генерация документа повестки годового общего собрания пайщиков
  */
@@ -18762,7 +19052,7 @@ declare const mutation$r: {
         meta: boolean;
     }];
 };
-interface IInput$H {
+interface IInput$J {
     /**
      * @private
      */
@@ -18770,13 +19060,13 @@ interface IInput$H {
     data: ModelTypes['AnnualGeneralMeetingAgendaGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$H = InputType<GraphQLTypes['Mutation'], typeof mutation$r>;
+type IOutput$J = InputType<GraphQLTypes['Mutation'], typeof mutation$r>;
 
 declare namespace generateAnnualGeneralMeetAgendaDocument {
-  export { type IInput$H as IInput, type IOutput$H as IOutput, mutation$r as mutation, name$G as name };
+  export { type IInput$J as IInput, type IOutput$J as IOutput, mutation$r as mutation, name$I as name };
 }
 
-declare const name$F = "generateAnnualGeneralMeetDecisionDocument";
+declare const name$H = "generateAnnualGeneralMeetDecisionDocument";
 /**
  * Генерация документа решения годового общего собрания пайщиков
  */
@@ -18792,7 +19082,7 @@ declare const mutation$q: {
         meta: boolean;
     }];
 };
-interface IInput$G {
+interface IInput$I {
     /**
      * @private
      */
@@ -18800,13 +19090,13 @@ interface IInput$G {
     data: ModelTypes['AnnualGeneralMeetingDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$G = InputType<GraphQLTypes['Mutation'], typeof mutation$q>;
+type IOutput$I = InputType<GraphQLTypes['Mutation'], typeof mutation$q>;
 
 declare namespace generateAnnualGeneralMeetDecisionDocument {
-  export { type IInput$G as IInput, type IOutput$G as IOutput, mutation$q as mutation, name$F as name };
+  export { type IInput$I as IInput, type IOutput$I as IOutput, mutation$q as mutation, name$H as name };
 }
 
-declare const name$E = "generateAnnualGeneralMeetNotificationDocument";
+declare const name$G = "generateAnnualGeneralMeetNotificationDocument";
 /**
  * Генерация документа уведомления о проведении годового общего собрания пайщиков
  */
@@ -18822,7 +19112,7 @@ declare const mutation$p: {
         meta: boolean;
     }];
 };
-interface IInput$F {
+interface IInput$H {
     /**
      * @private
      */
@@ -18830,13 +19120,13 @@ interface IInput$F {
     data: ModelTypes['AnnualGeneralMeetingNotificationGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$F = InputType<GraphQLTypes['Mutation'], typeof mutation$p>;
+type IOutput$H = InputType<GraphQLTypes['Mutation'], typeof mutation$p>;
 
 declare namespace generateAnnualGeneralMeetNotificationDocument {
-  export { type IInput$F as IInput, type IOutput$F as IOutput, mutation$p as mutation, name$E as name };
+  export { type IInput$H as IInput, type IOutput$H as IOutput, mutation$p as mutation, name$G as name };
 }
 
-declare const name$D = "generateBallotForAnnualGeneralMeetDocument";
+declare const name$F = "generateBallotForAnnualGeneralMeetDocument";
 /**
  * Генерация бюллетеня для голосования на общем собрании пайщиков
  */
@@ -18852,7 +19142,7 @@ declare const mutation$o: {
         meta: boolean;
     }];
 };
-interface IInput$E {
+interface IInput$G {
     /**
      * @private
      */
@@ -18860,13 +19150,13 @@ interface IInput$E {
     data: ModelTypes['AnnualGeneralMeetingVotingBallotGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$E = InputType<GraphQLTypes['Mutation'], typeof mutation$o>;
+type IOutput$G = InputType<GraphQLTypes['Mutation'], typeof mutation$o>;
 
 declare namespace generateBallotForAnnualGeneralMeetDocument {
-  export { type IInput$E as IInput, type IOutput$E as IOutput, mutation$o as mutation, name$D as name };
+  export { type IInput$G as IInput, type IOutput$G as IOutput, mutation$o as mutation, name$F as name };
 }
 
-declare const name$C = "generateSovietDecisionOnAnnualMeetDocument";
+declare const name$E = "generateSovietDecisionOnAnnualMeetDocument";
 /**
  * Генерация документа решения совета о проведении годового общего собрания пайщиков
  */
@@ -18882,7 +19172,7 @@ declare const mutation$n: {
         meta: boolean;
     }];
 };
-interface IInput$D {
+interface IInput$F {
     /**
      * @private
      */
@@ -18890,13 +19180,13 @@ interface IInput$D {
     data: ModelTypes['AnnualGeneralMeetingSovietDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$D = InputType<GraphQLTypes['Mutation'], typeof mutation$n>;
+type IOutput$F = InputType<GraphQLTypes['Mutation'], typeof mutation$n>;
 
 declare namespace generateSovietDecisionOnAnnualMeetDocument {
-  export { type IInput$D as IInput, type IOutput$D as IOutput, mutation$n as mutation, name$C as name };
+  export { type IInput$F as IInput, type IOutput$F as IOutput, mutation$n as mutation, name$E as name };
 }
 
-declare const name$B = "notifyOnAnnualGeneralMeet";
+declare const name$D = "notifyOnAnnualGeneralMeet";
 /**
  * Уведомление о проведении общего собрания пайщиков
  */
@@ -19610,20 +19900,20 @@ declare const mutation$m: {
         };
     }];
 };
-interface IInput$C {
+interface IInput$E {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['NotifyOnAnnualGeneralMeetInput'];
 }
-type IOutput$C = InputType<GraphQLTypes['Mutation'], typeof mutation$m>;
+type IOutput$E = InputType<GraphQLTypes['Mutation'], typeof mutation$m>;
 
 declare namespace notifyOnAnnualGeneralMeet {
-  export { type IInput$C as IInput, type IOutput$C as IOutput, mutation$m as mutation, name$B as name };
+  export { type IInput$E as IInput, type IOutput$E as IOutput, mutation$m as mutation, name$D as name };
 }
 
-declare const name$A = "restartAnnualGeneralMeet";
+declare const name$C = "restartAnnualGeneralMeet";
 /**
  * Перезапуск годового общего собрания пайщиков
  */
@@ -20337,20 +20627,20 @@ declare const mutation$l: {
         };
     }];
 };
-interface IInput$B {
+interface IInput$D {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['RestartAnnualGeneralMeetInput'];
 }
-type IOutput$B = InputType<GraphQLTypes['Mutation'], typeof mutation$l>;
+type IOutput$D = InputType<GraphQLTypes['Mutation'], typeof mutation$l>;
 
 declare namespace restartAnnualGeneralMeet {
-  export { type IInput$B as IInput, type IOutput$B as IOutput, mutation$l as mutation, name$A as name };
+  export { type IInput$D as IInput, type IOutput$D as IOutput, mutation$l as mutation, name$C as name };
 }
 
-declare const name$z = "signByPresiderOnAnnualGeneralMeet";
+declare const name$B = "signByPresiderOnAnnualGeneralMeet";
 /**
  * Подписание решения председателем на годовом общем собрании пайщиков
  */
@@ -21064,20 +21354,20 @@ declare const mutation$k: {
         };
     }];
 };
-interface IInput$A {
+interface IInput$C {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SignByPresiderOnAnnualGeneralMeetInput'];
 }
-type IOutput$A = InputType<GraphQLTypes['Mutation'], typeof mutation$k>;
+type IOutput$C = InputType<GraphQLTypes['Mutation'], typeof mutation$k>;
 
 declare namespace signByPresiderOnAnnualGeneralMeet {
-  export { type IInput$A as IInput, type IOutput$A as IOutput, mutation$k as mutation, name$z as name };
+  export { type IInput$C as IInput, type IOutput$C as IOutput, mutation$k as mutation, name$B as name };
 }
 
-declare const name$y = "signBySecretaryOnAnnualGeneralMeet";
+declare const name$A = "signBySecretaryOnAnnualGeneralMeet";
 /**
  * Подписание решения секретарём на годовом общем собрании пайщиков
  */
@@ -21791,20 +22081,20 @@ declare const mutation$j: {
         };
     }];
 };
-interface IInput$z {
+interface IInput$B {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SignBySecretaryOnAnnualGeneralMeetInput'];
 }
-type IOutput$z = InputType<GraphQLTypes['Mutation'], typeof mutation$j>;
+type IOutput$B = InputType<GraphQLTypes['Mutation'], typeof mutation$j>;
 
 declare namespace signBySecretaryOnAnnualGeneralMeet {
-  export { type IInput$z as IInput, type IOutput$z as IOutput, mutation$j as mutation, name$y as name };
+  export { type IInput$B as IInput, type IOutput$B as IOutput, mutation$j as mutation, name$A as name };
 }
 
-declare const name$x = "voteOnAnnualGeneralMeet";
+declare const name$z = "voteOnAnnualGeneralMeet";
 /**
  * Голосование на общем собрании пайщиков
  */
@@ -22518,26 +22808,26 @@ declare const mutation$i: {
         };
     }];
 };
-interface IInput$y {
+interface IInput$A {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['VoteOnAnnualGeneralMeetInput'];
 }
-type IOutput$y = InputType<GraphQLTypes['Mutation'], typeof mutation$i>;
+type IOutput$A = InputType<GraphQLTypes['Mutation'], typeof mutation$i>;
 
 declare namespace voteOnAnnualGeneralMeet {
-  export { type IInput$y as IInput, type IOutput$y as IOutput, mutation$i as mutation, name$x as name };
+  export { type IInput$A as IInput, type IOutput$A as IOutput, mutation$i as mutation, name$z as name };
 }
 
 /** Сгенерировать документ предложения повестки очередного общего собрания пайщиков */
 
-declare namespace index$k {
+declare namespace index$l {
   export { createAnnualGeneralMeet as CreateAnnualGeneralMeet, generateAnnualGeneralMeetAgendaDocument as GenerateAnnualGeneralMeetAgendaDocument, generateAnnualGeneralMeetDecisionDocument as GenerateAnnualGeneralMeetDecisionDocument, generateAnnualGeneralMeetNotificationDocument as GenerateAnnualGeneralMeetNotificationDocument, generateBallotForAnnualGeneralMeetDocument as GenerateBallotForAnnualGeneralMeetDocument, generateSovietDecisionOnAnnualMeetDocument as GenerateSovietDecisionOnAnnualMeetDocument, notifyOnAnnualGeneralMeet as NotifyOnAnnualGeneralMeet, restartAnnualGeneralMeet as RestartAnnualGeneralMeet, signByPresiderOnAnnualGeneralMeet as SignByPresiderOnAnnualGeneralMeet, signBySecretaryOnAnnualGeneralMeet as SignBySecretaryOnAnnualGeneralMeet, voteOnAnnualGeneralMeet as VoteOnAnnualGeneralMeet };
 }
 
-declare const name$w = "createWebPushSubscription";
+declare const name$y = "createWebPushSubscription";
 /**
  * Создать веб-пуш подписку для пользователя
  */
@@ -22560,20 +22850,20 @@ declare const mutation$h: {
         };
     }];
 };
-interface IInput$x {
+interface IInput$z {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateSubscriptionInput'];
 }
-type IOutput$x = InputType<GraphQLTypes['Mutation'], typeof mutation$h>;
+type IOutput$z = InputType<GraphQLTypes['Mutation'], typeof mutation$h>;
 
 declare namespace createWebPushSubscription {
-  export { type IInput$x as IInput, type IOutput$x as IOutput, mutation$h as mutation, name$w as name };
+  export { type IInput$z as IInput, type IOutput$z as IOutput, mutation$h as mutation, name$y as name };
 }
 
-declare const name$v = "deactivateWebPushSubscriptionById";
+declare const name$x = "deactivateWebPushSubscriptionById";
 /**
  * Деактивировать веб-пуш подписку по ID
  */
@@ -22582,26 +22872,26 @@ declare const mutation$g: {
         data: Variable<"DeactivateSubscriptionInput!", "data">;
     }, true];
 };
-interface IInput$w {
+interface IInput$y {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeactivateSubscriptionInput'];
 }
-type IOutput$w = InputType<GraphQLTypes['Mutation'], typeof mutation$g>;
+type IOutput$y = InputType<GraphQLTypes['Mutation'], typeof mutation$g>;
 
 declare namespace deactivateWebPushSubscriptionById {
-  export { type IInput$w as IInput, type IOutput$w as IOutput, mutation$g as mutation, name$v as name };
+  export { type IInput$y as IInput, type IOutput$y as IOutput, mutation$g as mutation, name$x as name };
 }
 
 /** Создать веб-пуш подписку для пользователя */
 
-declare namespace index$j {
+declare namespace index$k {
   export { createWebPushSubscription as CreateWebPushSubscription, deactivateWebPushSubscriptionById as DeactivateWebPushSubscriptionById };
 }
 
-declare const name$u = "addParticipant";
+declare const name$w = "addParticipant";
 declare const mutation$f: {
     addParticipant: [{
         data: Variable<"AddParticipantInput!", "data">;
@@ -22786,20 +23076,20 @@ declare const mutation$f: {
         };
     }];
 };
-interface IInput$v {
+interface IInput$x {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['AddParticipantInput'];
 }
-type IOutput$v = InputType<GraphQLTypes['Mutation'], typeof mutation$f>;
+type IOutput$x = InputType<GraphQLTypes['Mutation'], typeof mutation$f>;
 
 declare namespace addParticipant {
-  export { type IInput$v as IInput, type IOutput$v as IOutput, mutation$f as mutation, name$u as name };
+  export { type IInput$x as IInput, type IOutput$x as IOutput, mutation$f as mutation, name$w as name };
 }
 
-declare const name$t = "generateParticipantApplication";
+declare const name$v = "generateParticipantApplication";
 declare const mutation$e: {
     generateParticipantApplication: [{
         data: Variable<"ParticipantApplicationGenerateDocumentInput!", "data">;
@@ -22812,7 +23102,7 @@ declare const mutation$e: {
         meta: boolean;
     }];
 };
-interface IInput$u {
+interface IInput$w {
     /**
      * @private
      */
@@ -22820,13 +23110,13 @@ interface IInput$u {
     data: ModelTypes['ParticipantApplicationGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$u = InputType<GraphQLTypes['Mutation'], typeof mutation$e>;
+type IOutput$w = InputType<GraphQLTypes['Mutation'], typeof mutation$e>;
 
 declare namespace generateParticipantApplication {
-  export { type IInput$u as IInput, type IOutput$u as IOutput, mutation$e as mutation, name$t as name };
+  export { type IInput$w as IInput, type IOutput$w as IOutput, mutation$e as mutation, name$v as name };
 }
 
-declare const name$s = "generateParticipantApplicationDecision";
+declare const name$u = "generateParticipantApplicationDecision";
 declare const mutation$d: {
     generateParticipantApplicationDecision: [{
         data: Variable<"ParticipantApplicationDecisionGenerateDocumentInput!", "data">;
@@ -22839,7 +23129,7 @@ declare const mutation$d: {
         meta: boolean;
     }];
 };
-interface IInput$t {
+interface IInput$v {
     /**
      * @private
      */
@@ -22847,13 +23137,13 @@ interface IInput$t {
     data: ModelTypes['ParticipantApplicationDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$t = InputType<GraphQLTypes['Mutation'], typeof mutation$d>;
+type IOutput$v = InputType<GraphQLTypes['Mutation'], typeof mutation$d>;
 
 declare namespace generateParticipantApplicationDecision {
-  export { type IInput$t as IInput, type IOutput$t as IOutput, mutation$d as mutation, name$s as name };
+  export { type IInput$v as IInput, type IOutput$v as IOutput, mutation$d as mutation, name$u as name };
 }
 
-declare const name$r = "registerParticipant";
+declare const name$t = "registerParticipant";
 declare const mutation$c: {
     registerParticipant: [{
         data: Variable<"RegisterParticipantInput!", "data">;
@@ -23038,20 +23328,20 @@ declare const mutation$c: {
         };
     }];
 };
-interface IInput$s {
+interface IInput$u {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['RegisterParticipantInput'];
 }
-type IOutput$s = InputType<GraphQLTypes['Mutation'], typeof mutation$c>;
+type IOutput$u = InputType<GraphQLTypes['Mutation'], typeof mutation$c>;
 
 declare namespace registerParticipant {
-  export { type IInput$s as IInput, type IOutput$s as IOutput, mutation$c as mutation, name$r as name };
+  export { type IInput$u as IInput, type IOutput$u as IOutput, mutation$c as mutation, name$t as name };
 }
 
-declare const name$q = "createInitialPayment";
+declare const name$s = "createInitialPayment";
 declare const mutation$b: {
     createInitialPayment: [{
         data: Variable<"CreateInitialPaymentInput!", "data">;
@@ -23123,13 +23413,13 @@ declare const mutation$b: {
         is_final: boolean;
     }];
 };
-interface IInput$r {
+interface IInput$t {
     data: ModelTypes['CreateInitialPaymentInput'];
 }
-type IOutput$r = InputType<GraphQLTypes['Mutation'], typeof mutation$b>;
+type IOutput$t = InputType<GraphQLTypes['Mutation'], typeof mutation$b>;
 
 declare namespace createInitialPayment {
-  export { type IInput$r as IInput, type IOutput$r as IOutput, mutation$b as mutation, name$q as name };
+  export { type IInput$t as IInput, type IOutput$t as IOutput, mutation$b as mutation, name$s as name };
 }
 
 /**
@@ -23167,11 +23457,11 @@ declare namespace createInitialPayment {
 ```
 /** Добавить активного пайщика, который вступил в кооператив, не используя платформу (заполнив заявление собственноручно, оплатив вступительный и минимальный паевый взносы, и получив протокол решения совета) */
 
-declare namespace index$i {
+declare namespace index$j {
   export { addParticipant as AddParticipant, createInitialPayment as CreateInitialPayment, generateParticipantApplication as GenerateParticipantApplication, generateParticipantApplicationDecision as GenerateParticipantApplicationDecision, registerParticipant as RegisterParticipant };
 }
 
-declare const name$p = "createBankAccount";
+declare const name$r = "createBankAccount";
 declare const mutation$a: {
     createBankAccount: [{
         data: Variable<"CreateBankAccountInput!", "data">;
@@ -23201,39 +23491,39 @@ declare const mutation$a: {
         username: boolean;
     }];
 };
-interface IInput$q {
+interface IInput$s {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['CreateBankAccountInput'];
 }
-type IOutput$q = InputType<GraphQLTypes['Mutation'], typeof mutation$a>;
+type IOutput$s = InputType<GraphQLTypes['Mutation'], typeof mutation$a>;
 
 declare namespace createBankAccount {
-  export { type IInput$q as IInput, type IOutput$q as IOutput, mutation$a as mutation, name$p as name };
+  export { type IInput$s as IInput, type IOutput$s as IOutput, mutation$a as mutation, name$r as name };
 }
 
-declare const name$o = "deletePaymentMethod";
+declare const name$q = "deletePaymentMethod";
 declare const mutation$9: {
     deletePaymentMethod: [{
         data: Variable<"DeletePaymentMethodInput!", "data">;
     }, true];
 };
-interface IInput$p {
+interface IInput$r {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['DeletePaymentMethodInput'];
 }
-type IOutput$p = InputType<GraphQLTypes['Mutation'], typeof mutation$9>;
+type IOutput$r = InputType<GraphQLTypes['Mutation'], typeof mutation$9>;
 
 declare namespace deletePaymentMethod {
-  export { type IInput$p as IInput, type IOutput$p as IOutput, mutation$9 as mutation, name$o as name };
+  export { type IInput$r as IInput, type IOutput$r as IOutput, mutation$9 as mutation, name$q as name };
 }
 
-declare const name$n = "updateBankAccount";
+declare const name$p = "updateBankAccount";
 declare const mutation$8: {
     updateBankAccount: [{
         data: Variable<"UpdateBankAccountInput!", "data">;
@@ -23263,26 +23553,26 @@ declare const mutation$8: {
         username: boolean;
     }];
 };
-interface IInput$o {
+interface IInput$q {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['UpdateBankAccountInput'];
 }
-type IOutput$o = InputType<GraphQLTypes['Mutation'], typeof mutation$8>;
+type IOutput$q = InputType<GraphQLTypes['Mutation'], typeof mutation$8>;
 
 declare namespace updateBankAccount {
-  export { type IInput$o as IInput, type IOutput$o as IOutput, mutation$8 as mutation, name$n as name };
+  export { type IInput$q as IInput, type IOutput$q as IOutput, mutation$8 as mutation, name$p as name };
 }
 
 /** Добавить метод оплаты */
 
-declare namespace index$h {
+declare namespace index$i {
   export { createBankAccount as CreateBankAccount, deletePaymentMethod as DeletePaymentMethod, updateBankAccount as UpdateBankAccount };
 }
 
-declare const name$m = "initSystem";
+declare const name$o = "initSystem";
 declare const mutation$7: {
     initSystem: [{
         data: Variable<"Init!", "data">;
@@ -23511,20 +23801,20 @@ declare const mutation$7: {
         };
     }];
 };
-interface IInput$n {
+interface IInput$p {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['Init'];
 }
-type IOutput$n = InputType<GraphQLTypes['Mutation'], typeof mutation$7>;
+type IOutput$p = InputType<GraphQLTypes['Mutation'], typeof mutation$7>;
 
 declare namespace initSystem {
-  export { type IInput$n as IInput, type IOutput$n as IOutput, mutation$7 as mutation, name$m as name };
+  export { type IInput$p as IInput, type IOutput$p as IOutput, mutation$7 as mutation, name$o as name };
 }
 
-declare const name$l = "installSystem";
+declare const name$n = "installSystem";
 declare const mutation$6: {
     installSystem: [{
         data: Variable<"Install!", "data">;
@@ -23753,39 +24043,39 @@ declare const mutation$6: {
         };
     }];
 };
-interface IInput$m {
+interface IInput$o {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['Install'];
 }
-type IOutput$m = InputType<GraphQLTypes['Mutation'], typeof mutation$6>;
+type IOutput$o = InputType<GraphQLTypes['Mutation'], typeof mutation$6>;
 
 declare namespace installSystem {
-  export { type IInput$m as IInput, type IOutput$m as IOutput, mutation$6 as mutation, name$l as name };
+  export { type IInput$o as IInput, type IOutput$o as IOutput, mutation$6 as mutation, name$n as name };
 }
 
-declare const name$k = "setWif";
+declare const name$m = "setWif";
 declare const mutation$5: {
     setWif: [{
         data: Variable<"SetWifInput!", "data">;
     }, true];
 };
-interface IInput$l {
+interface IInput$n {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SetWifInput'];
 }
-type IOutput$l = InputType<GraphQLTypes['Mutation'], typeof mutation$5>;
+type IOutput$n = InputType<GraphQLTypes['Mutation'], typeof mutation$5>;
 
 declare namespace saveWif {
-  export { type IInput$l as IInput, type IOutput$l as IOutput, mutation$5 as mutation, name$k as name };
+  export { type IInput$n as IInput, type IOutput$n as IOutput, mutation$5 as mutation, name$m as name };
 }
 
-declare const name$j = "updateSystem";
+declare const name$l = "updateSystem";
 declare const mutation$4: {
     updateSystem: [{
         data: Variable<"Update!", "data">;
@@ -24014,26 +24304,26 @@ declare const mutation$4: {
         };
     }];
 };
-interface IInput$k {
+interface IInput$m {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['Update'];
 }
-type IOutput$k = InputType<GraphQLTypes['Mutation'], typeof mutation$4>;
+type IOutput$m = InputType<GraphQLTypes['Mutation'], typeof mutation$4>;
 
 declare namespace updateSystem {
-  export { type IInput$k as IInput, type IOutput$k as IOutput, mutation$4 as mutation, name$j as name };
+  export { type IInput$m as IInput, type IOutput$m as IOutput, mutation$4 as mutation, name$l as name };
 }
 
 /** Произвести инициализацию программного обеспечения перед установкой совета методом install */
 
-declare namespace index$g {
+declare namespace index$h {
   export { initSystem as InitSystem, installSystem as InstallSystem, saveWif as SaveWif, updateSystem as UpdateSystem };
 }
 
-declare const name$i = "createWithdraw";
+declare const name$k = "createWithdraw";
 declare const mutation$3: {
     createWithdraw: [{
         input: Variable<"CreateWithdrawInput!", "input">;
@@ -24041,18 +24331,18 @@ declare const mutation$3: {
         withdraw_hash: boolean;
     }];
 };
-interface IInput$j {
+interface IInput$l {
     input: ModelTypes['CreateWithdrawInput'];
 }
-type IOutput$j = {
-    [name$i]: ModelTypes['CreateWithdrawResponse'];
+type IOutput$l = {
+    [name$k]: ModelTypes['CreateWithdrawResponse'];
 };
 
 declare namespace createWithdraw {
-  export { type IInput$j as IInput, type IOutput$j as IOutput, mutation$3 as mutation, name$i as name };
+  export { type IInput$l as IInput, type IOutput$l as IOutput, mutation$3 as mutation, name$k as name };
 }
 
-declare const name$h = "createDepositPayment";
+declare const name$j = "createDepositPayment";
 declare const mutation$2: {
     createDepositPayment: [{
         data: Variable<"CreateDepositPaymentInput!", "data">;
@@ -24124,16 +24414,16 @@ declare const mutation$2: {
         is_final: boolean;
     }];
 };
-interface IInput$i {
+interface IInput$k {
     data: ModelTypes['CreateDepositPaymentInput'];
 }
-type IOutput$i = InputType<GraphQLTypes['Mutation'], typeof mutation$2>;
+type IOutput$k = InputType<GraphQLTypes['Mutation'], typeof mutation$2>;
 
 declare namespace createDepositPayment {
-  export { type IInput$i as IInput, type IOutput$i as IOutput, mutation$2 as mutation, name$h as name };
+  export { type IInput$k as IInput, type IOutput$k as IOutput, mutation$2 as mutation, name$j as name };
 }
 
-declare const name$g = "generateReturnByMoneyStatementDocument";
+declare const name$i = "generateReturnByMoneyStatementDocument";
 declare const mutation$1: {
     generateReturnByMoneyStatementDocument: [{
         data: Variable<"ReturnByMoneyGenerateDocumentInput!", "data">;
@@ -24146,19 +24436,19 @@ declare const mutation$1: {
         meta: boolean;
     }];
 };
-interface IInput$h {
+interface IInput$j {
     data: ModelTypes['ReturnByMoneyGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$h = {
-    [name$g]: ModelTypes['GeneratedDocument'];
+type IOutput$j = {
+    [name$i]: ModelTypes['GeneratedDocument'];
 };
 
 declare namespace generateReturnByMoneyStatementDocument {
-  export { type IInput$h as IInput, type IOutput$h as IOutput, mutation$1 as mutation, name$g as name };
+  export { type IInput$j as IInput, type IOutput$j as IOutput, mutation$1 as mutation, name$i as name };
 }
 
-declare const name$f = "generateReturnByMoneyDecisionDocument";
+declare const name$h = "generateReturnByMoneyDecisionDocument";
 declare const mutation: {
     generateReturnByMoneyDecisionDocument: [{
         data: Variable<"ReturnByMoneyDecisionGenerateDocumentInput!", "data">;
@@ -24171,34 +24461,34 @@ declare const mutation: {
         meta: boolean;
     }];
 };
-interface IInput$g {
+interface IInput$i {
     data: ModelTypes['ReturnByMoneyDecisionGenerateDocumentInput'];
     options?: ModelTypes['GenerateDocumentOptionsInput'];
 }
-type IOutput$g = {
-    [name$f]: ModelTypes['GeneratedDocument'];
+type IOutput$i = {
+    [name$h]: ModelTypes['GeneratedDocument'];
 };
 
 declare const generateReturnByMoneyDecisionDocument_mutation: typeof mutation;
 declare namespace generateReturnByMoneyDecisionDocument {
-  export { type IInput$g as IInput, type IOutput$g as IOutput, generateReturnByMoneyDecisionDocument_mutation as mutation, name$f as name };
+  export { type IInput$i as IInput, type IOutput$i as IOutput, generateReturnByMoneyDecisionDocument_mutation as mutation, name$h as name };
 }
 
 /** Создать заявку на вывод средств */
 
-declare namespace index$f {
+declare namespace index$g {
   export { createDepositPayment as CreateDepositPayment, createWithdraw as CreateWithdraw, generateReturnByMoneyDecisionDocument as GenerateReturnByMoneyDecisionDocument, generateReturnByMoneyStatementDocument as GenerateReturnByMoneyStatementDocument };
 }
 
 declare namespace Mutations {
-  export { index$s as Accounts, index$r as Agreements, index$q as Auth, index$p as Branches, index$o as Cooplace, index$n as Extensions, index$m as FreeDecisions, index$l as Gateway, index$k as Meet, index$j as Notification, index$i as Participants, index$h as PaymentMethods, index$g as System, index$f as Wallet };
+  export { index$t as Accounts, index$s as Agreements, index$r as Auth, index$q as Branches, index$p as Cooplace, index$o as Extensions, index$n as FreeDecisions, index$m as Gateway, index$l as Meet, index$k as Notification, index$j as Participants, index$i as PaymentMethods, index$h as System, index$g as Wallet };
 }
 
-declare const name$e = "getAccount";
+declare const name$g = "getAccount";
 /**
  * Извлекает комплексную информацию о аккаунте
  */
-declare const query$f: {
+declare const query$h: {
     getAccount: [{
         data: Variable<"GetAccountInput!", "data">;
     }, {
@@ -24382,24 +24672,24 @@ declare const query$f: {
         };
     }];
 };
-interface IInput$f {
+interface IInput$h {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['GetAccountInput'];
 }
-type IOutput$f = InputType<GraphQLTypes['Query'], typeof query$f>;
+type IOutput$h = InputType<GraphQLTypes['Query'], typeof query$h>;
 
 declare namespace getAccount {
-  export { type IInput$f as IInput, type IOutput$f as IOutput, name$e as name, query$f as query };
+  export { type IInput$h as IInput, type IOutput$h as IOutput, name$g as name, query$h as query };
 }
 
-declare const name$d = "getAccounts";
+declare const name$f = "getAccounts";
 /**
  * Извлекает комплексную информацию о аккаунтах с постраничным отображением
  */
-declare const query$e: {
+declare const query$g: {
     getAccounts: [{
         data: Variable<"GetAccountsInput", "data">;
         options: Variable<"PaginationInput", "options">;
@@ -24589,7 +24879,7 @@ declare const query$e: {
         currentPage: boolean;
     }];
 };
-interface IInput$e {
+interface IInput$g {
     /**
      * @private
      */
@@ -24597,17 +24887,17 @@ interface IInput$e {
     data?: ModelTypes['GetAccountsInput'];
     options?: ModelTypes['PaginationInput'];
 }
-type IOutput$e = InputType<GraphQLTypes['Query'], typeof query$e>;
+type IOutput$g = InputType<GraphQLTypes['Query'], typeof query$g>;
 
 declare namespace getAccounts {
-  export { type IInput$e as IInput, type IOutput$e as IOutput, name$d as name, query$e as query };
+  export { type IInput$g as IInput, type IOutput$g as IOutput, name$f as name, query$g as query };
 }
 
-declare const name$c = "searchPrivateAccounts";
+declare const name$e = "searchPrivateAccounts";
 /**
  * Поиск приватных данных аккаунтов по запросу
  */
-declare const query$d: {
+declare const query$f: {
     searchPrivateAccounts: [{
         data: Variable<"SearchPrivateAccountsInput!", "data">;
     }, {
@@ -24675,32 +24965,32 @@ declare const query$d: {
         };
     }];
 };
-interface IInput$d {
+interface IInput$f {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['SearchPrivateAccountsInput'];
 }
-type IOutput$d = InputType<GraphQLTypes['Query'], typeof query$d>;
+type IOutput$f = InputType<GraphQLTypes['Query'], typeof query$f>;
 
 declare namespace searchPrivateAccounts {
-  export { type IInput$d as IInput, type IOutput$d as IOutput, name$c as name, query$d as query };
+  export { type IInput$f as IInput, type IOutput$f as IOutput, name$e as name, query$f as query };
 }
 
 /**
 
 /** Получить сводную информацию о аккаунте */
 
-declare namespace index$e {
+declare namespace index$f {
   export { getAccount as GetAccount, getAccounts as GetAccounts, searchPrivateAccounts as SearchPrivateAccounts };
 }
 
-declare const name$b = "getAgenda";
+declare const name$d = "getAgenda";
 /**
  * Извлекает информацию о состоянии системы
  */
-declare const query$c: {
+declare const query$e: {
     getAgenda: {
         action: {
             account: boolean;
@@ -25510,29 +25800,29 @@ declare const query$c: {
         };
     };
 };
-interface IInput$c {
+interface IInput$e {
     /**
      * @private
      */
     [key: string]: unknown;
 }
-type IOutput$c = InputType<GraphQLTypes['Query'], typeof query$c>;
+type IOutput$e = InputType<GraphQLTypes['Query'], typeof query$e>;
 
 declare namespace getAgenda {
-  export { type IInput$c as IInput, type IOutput$c as IOutput, name$b as name, query$c as query };
+  export { type IInput$e as IInput, type IOutput$e as IOutput, name$d as name, query$e as query };
 }
 
 /** Получить список вопросов совета кооператива для голосования */
 
-declare namespace index$d {
+declare namespace index$e {
   export { getAgenda as GetAgenda };
 }
 
-declare const name$a = "getBranches";
+declare const name$c = "getBranches";
 /**
  * Извлекает подробную информацию о кооперативных участках
  */
-declare const query$b: {
+declare const query$d: {
     getBranches: [{
         data: Variable<"GetBranchesInput!", "data">;
     }, {
@@ -25614,24 +25904,24 @@ declare const query$b: {
         type: boolean;
     }];
 };
-interface IInput$b {
+interface IInput$d {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['GetBranchesInput'];
 }
-type IOutput$b = InputType<GraphQLTypes['Query'], typeof query$b>;
+type IOutput$d = InputType<GraphQLTypes['Query'], typeof query$d>;
 
 declare namespace getBranches {
-  export { type IInput$b as IInput, type IOutput$b as IOutput, name$a as name, query$b as query };
+  export { type IInput$d as IInput, type IOutput$d as IOutput, name$c as name, query$d as query };
 }
 
-declare const name$9 = "getBranches";
+declare const name$b = "getBranches";
 /**
  * Извлекает информацию о кооперативных участках для пользователя с ролью user
  */
-declare const query$a: {
+declare const query$c: {
     getBranches: [{
         data: Variable<"GetBranchesInput!", "data">;
     }, {
@@ -25679,30 +25969,30 @@ declare const query$a: {
         type: boolean;
     }];
 };
-interface IInput$a {
+interface IInput$c {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['GetBranchesInput'];
 }
-type IOutput$a = InputType<GraphQLTypes['Query'], typeof query$a>;
+type IOutput$c = InputType<GraphQLTypes['Query'], typeof query$c>;
 
 declare namespace getPublicBranches {
-  export { type IInput$a as IInput, type IOutput$a as IOutput, name$9 as name, query$a as query };
+  export { type IInput$c as IInput, type IOutput$c as IOutput, name$b as name, query$c as query };
 }
 
 /** Получить список кооперативных участков */
 
-declare namespace index$c {
+declare namespace index$d {
   export { getBranches as GetBranches, getPublicBranches as GetPublicBranches };
 }
 
-declare const name$8 = "getDesktop";
+declare const name$a = "getDesktop";
 /**
  * Извлекает рабочий стол
  */
-declare const query$9: {
+declare const query$b: {
     getDesktop: {
         coopname: boolean;
         layout: boolean;
@@ -25714,29 +26004,29 @@ declare const query$9: {
         };
     };
 };
-interface IInput$9 {
+interface IInput$b {
     /**
      * @private
      */
     [key: string]: unknown;
 }
-type IOutput$9 = InputType<GraphQLTypes['Query'], typeof query$9>;
+type IOutput$b = InputType<GraphQLTypes['Query'], typeof query$b>;
 
 declare namespace getDesktop {
-  export { type IInput$9 as IInput, type IOutput$9 as IOutput, name$8 as name, query$9 as query };
+  export { type IInput$b as IInput, type IOutput$b as IOutput, name$a as name, query$b as query };
 }
 
 /** Получить состав приложений рабочего стола */
 
-declare namespace index$b {
+declare namespace index$c {
   export { getDesktop as GetDesktop };
 }
 
-declare const name$7 = "getDocuments";
+declare const name$9 = "getDocuments";
 /**
  * Извлекает документы с агрегатами
  */
-declare const query$8: {
+declare const query$a: {
     getDocuments: [{
         data: Variable<"GetDocumentsInput!", "data">;
     }, {
@@ -26311,28 +26601,28 @@ declare const query$8: {
         currentPage: boolean;
     }];
 };
-interface IInput$8 {
+interface IInput$a {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['GetDocumentsInput'];
 }
-type IOutput$8 = InputType<GraphQLTypes['Query'], typeof query$8>;
+type IOutput$a = InputType<GraphQLTypes['Query'], typeof query$a>;
 
 declare namespace getDocuments {
-  export { type IInput$8 as IInput, type IOutput$8 as IOutput, name$7 as name, query$8 as query };
+  export { type IInput$a as IInput, type IOutput$a as IOutput, name$9 as name, query$a as query };
 }
 
-declare namespace index$a {
+declare namespace index$b {
   export { getDocuments as GetDocuments };
 }
 
-declare const name$6 = "getExtensions";
+declare const name$8 = "getExtensions";
 /**
  * Извлекает расширения
  */
-declare const query$7: {
+declare const query$9: {
     getExtensions: [{
         data: Variable<"GetExtensionsInput", "data">;
     }, {
@@ -26356,27 +26646,27 @@ declare const query$7: {
         instructions: boolean;
     }];
 };
-interface IInput$7 {
+interface IInput$9 {
     /**
      * @private
      */
     [key: string]: unknown;
     data: ModelTypes['GetExtensionsInput'];
 }
-type IOutput$7 = InputType<GraphQLTypes['Query'], typeof query$7>;
+type IOutput$9 = InputType<GraphQLTypes['Query'], typeof query$9>;
 
 declare namespace getExtensions {
-  export { type IInput$7 as IInput, type IOutput$7 as IOutput, name$6 as name, query$7 as query };
+  export { type IInput$9 as IInput, type IOutput$9 as IOutput, name$8 as name, query$9 as query };
 }
 
 /** Получить список расширений */
 
-declare namespace index$9 {
+declare namespace index$a {
   export { getExtensions as GetExtensions };
 }
 
-declare const name$5 = "getPayments";
-declare const query$6: {
+declare const name$7 = "getPayments";
+declare const query$8: {
     getPayments: [{
         data: Variable<"PaymentFiltersInput", "data">;
         options: Variable<"PaginationInput", "options">;
@@ -26453,22 +26743,95 @@ declare const query$6: {
         currentPage: boolean;
     }];
 };
-interface IInput$6 {
+interface IInput$8 {
     data?: ModelTypes['PaymentFiltersInput'];
     options?: ModelTypes['PaginationInput'];
 }
-type IOutput$6 = InputType<GraphQLTypes['Query'], typeof query$6>;
+type IOutput$8 = InputType<GraphQLTypes['Query'], typeof query$8>;
 
 declare namespace getPayments {
-  export { type IInput$6 as IInput, type IOutput$6 as IOutput, name$5 as name, query$6 as query };
+  export { type IInput$8 as IInput, type IOutput$8 as IOutput, name$7 as name, query$8 as query };
 }
 
 /** Получить список платежей с возможностью фильтрации по типу, статусу и направлению. */
 
-declare namespace index$8 {
+declare namespace index$9 {
   export { getPayments as GetPayments };
 }
 
+declare const name$6 = "getLedger";
+/**
+ * Получить полное состояние плана счетов кооператива
+ */
+declare const query$7: {
+    getLedger: [{
+        data: Variable<"GetLedgerInput!", "data">;
+    }, {
+        coopname: boolean;
+        chartOfAccounts: {
+            id: boolean;
+            displayId: boolean;
+            name: boolean;
+            available: boolean;
+            blocked: boolean;
+            writeoff: boolean;
+        };
+    }];
+};
+interface IInput$7 {
+    /**
+     * @private
+     */
+    [key: string]: unknown;
+    data: ModelTypes['GetLedgerInput'];
+}
+type IOutput$7 = InputType<GraphQLTypes['Query'], typeof query$7>;
+
+declare namespace getLedger {
+  export { type IInput$7 as IInput, type IOutput$7 as IOutput, name$6 as name, query$7 as query };
+}
+
+declare const name$5 = "getLedgerHistory";
+/**
+ * Получить историю операций по счетам кооператива
+ */
+declare const query$6: {
+    getLedgerHistory: [{
+        data: Variable<"GetLedgerHistoryInput!", "data">;
+    }, {
+        items: {
+            global_sequence: boolean;
+            coopname: boolean;
+            action: boolean;
+            created_at: boolean;
+            account_id: boolean;
+            quantity: boolean;
+            comment: boolean;
+        };
+        totalCount: boolean;
+        totalPages: boolean;
+        currentPage: boolean;
+    }];
+};
+interface IInput$6 {
+    /**
+     * @private
+     */
+    [key: string]: unknown;
+    data: ModelTypes['GetLedgerHistoryInput'];
+}
+type IOutput$6 = InputType<GraphQLTypes['Query'], typeof query$6>;
+
+declare namespace getLedgerHistory {
+  export { type IInput$6 as IInput, type IOutput$6 as IOutput, name$5 as name, query$6 as query };
+}
+
+/** Получить полное состояние плана счетов кооператива. Возвращает все счета из стандартного плана счетов с актуальными данными из блокчейна. Если счет не активен в блокчейне, возвращает нулевые значения. */
+
+declare namespace index$8 {
+  export { getLedger as GetLedger, getLedgerHistory as GetLedgerHistory };
+}
+
 declare const name$4 = "getMeet";
 /**
  * Получить данные собрания по хешу
@@ -28300,7 +28663,7 @@ declare namespace index$4 {
 }
 
 declare namespace index$3 {
-  export { index$e as Accounts, index$d as Agenda, index$c as Branches, index$b as Desktop, index$a as Documents, index$9 as Extensions, index$8 as Gateway, index$7 as Meet, index$6 as Notification, index$5 as PaymentMethods, index$4 as System };
+  export { index$f as Accounts, index$e as Agenda, index$d as Branches, index$c as Desktop, index$b as Documents, index$a as Extensions, index$9 as Gateway, index$8 as Ledger, index$7 as Meet, index$6 as Notification, index$5 as PaymentMethods, index$4 as System };
 }
 
 type index$2_BlockchainConfig = BlockchainConfig;
@@ -28491,7 +28854,7 @@ declare namespace index$1 {
 }
 
 declare namespace index {
-  export { index$2 as Blockchain, index$u as Client, index$1 as Controller, index$t as Document };
+  export { index$2 as Blockchain, index$v as Client, index$1 as Controller, index$u as Document };
 }
 
 declare class Client {
@@ -28521,7 +28884,7 @@ declare class Client {
      * @param wif Приватный ключ в формате WIF.
      * @returns Результат логина.
      */
-    login(email: string, wif: string): Promise<IOutput$1l['login']>;
+    login(email: string, wif: string): Promise<IOutput$1n['login']>;
     /**
      * Установка токена авторизации.
      * @param token Токен для заголовков Authorization.
@@ -28574,6 +28937,12 @@ declare class Client {
         getExtensions?: [{
             data?: ValueTypes["GetExtensionsInput"] | undefined | null | Variable<any, string>;
         }, ValueTypes["Extension"]];
+        getLedger?: [{
+            data: ValueTypes["GetLedgerInput"] | Variable<any, string>;
+        }, ValueTypes["LedgerState"]];
+        getLedgerHistory?: [{
+            data: ValueTypes["GetLedgerHistoryInput"] | Variable<any, string>;
+        }, ValueTypes["LedgerHistoryResponse"]];
         getMeet?: [{
             data: ValueTypes["GetMeetInput"] | Variable<any, string>;
         }, ValueTypes["MeetAggregate"]];
@@ -28596,7 +28965,7 @@ declare class Client {
             data: ValueTypes["SearchPrivateAccountsInput"] | Variable<any, string>;
         }, ValueTypes["PrivateAccountSearchResult"]];
         __typename?: boolean | `@${string}`;
-    }>>(o: Z & { [P in keyof Z]: P extends "__alias" | "__typename" | "__directives" | "getAccount" | "getAccounts" | "getAgenda" | "getBranches" | "getDesktop" | "getDocuments" | "getExtensions" | "getMeet" | "getMeets" | "getPaymentMethods" | "getPayments" | "getSystemInfo" | "getUserWebPushSubscriptions" | "getWebPushSubscriptionStats" | "searchPrivateAccounts" ? Z[P] : never; }, ops?: OperationOptions & {
+    }>>(o: Z & { [P in keyof Z]: P extends "__alias" | "__typename" | "__directives" | "getAccount" | "getAccounts" | "getAgenda" | "getBranches" | "getDesktop" | "getDocuments" | "getExtensions" | "getLedger" | "getLedgerHistory" | "getMeet" | "getMeets" | "getPaymentMethods" | "getPayments" | "getSystemInfo" | "getUserWebPushSubscriptions" | "getWebPushSubscriptionStats" | "searchPrivateAccounts" ? Z[P] : never; }, ops?: OperationOptions & {
         variables?: Record<string, unknown>;
     }) => Promise<InputType<{
         __typename: "Query";
@@ -28607,6 +28976,8 @@ declare class Client {
         getDesktop: GraphQLTypes["Desktop"];
         getDocuments: GraphQLTypes["DocumentsAggregatePaginationResult"];
         getExtensions: Array<GraphQLTypes["Extension"]>;
+        getLedger: GraphQLTypes["LedgerState"];
+        getLedgerHistory: GraphQLTypes["LedgerHistoryResponse"];
         getMeet: GraphQLTypes["MeetAggregate"];
         getMeets: Array<GraphQLTypes["MeetAggregate"]>;
         getPaymentMethods: GraphQLTypes["PaymentMethodPaginationResult"];
@@ -28974,4 +29345,4 @@ declare class Client {
     private static createThunder;
 }
 
-export { Classes, Client, Mutations, index$3 as Queries, index as Types, index$v as Zeus };
+export { Classes, Client, Mutations, index$3 as Queries, index as Types, index$w as Zeus };