@acequants/aegis-contracts 0.1.55 → 0.1.57

package/dist/src/gen/system/v1/system.d.ts

@@ -3,6 +3,162 @@ import _m0 from "protobufjs/minimal";
 import { Observable } from "rxjs";
 import { Timestamp } from "../../google/protobuf/timestamp";
 export declare const protobufPackage = "aegis.system.v1";
+export interface GrpcInputGeoSync {
+    /**
+     * Opaque cursor — for delta tables this is an ISO8601 string of
+     * the last seen `updated_at`; for bridge tables it is the last
+     * seen integer `id` rendered as decimal. Empty string = from start.
+     */
+    cursor: string;
+    /** Server clamps to [100, 2000]; 0 / unset → 500. */
+    pageSize: number;
+}
+export interface GrpcDtoGeoTimezone {
+    publicId: string;
+    iana: string;
+    updatedAt?: Timestamp | undefined;
+    /** nullable */
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoCurrency {
+    publicId: string;
+    code: string;
+    name: string;
+    /** nullable, empty = unset */
+    symbol: string;
+    isBase: boolean;
+    isActive: boolean;
+    /** Decimal serialised as string */
+    exchangeRate: string;
+    updatedAt?: Timestamp | undefined;
+    /** nullable */
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoLanguage {
+    publicId: string;
+    /** LANGUAGE enum as string */
+    iso6391: string;
+    /** nullable */
+    iso6392: string;
+    name: string;
+    isActive: boolean;
+    updatedAt?: Timestamp | undefined;
+    /** nullable */
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoLocale {
+    publicId: string;
+    languagePublicId: string;
+    code: string;
+    name: string;
+    /** GeoLocale has no deletedAt in aegis schema. */
+    updatedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoDivision {
+    publicId: string;
+    /** nullable */
+    timezonePublicId: string;
+    /** nullable */
+    currencyPublicId: string;
+    /** nullable */
+    parentPublicId: string;
+    /** GEO_DIVISION enum as string */
+    type: string;
+    level: number;
+    /** nullable */
+    code: string;
+    path: string;
+    /** nullable */
+    iso2: string;
+    /** nullable */
+    iso3: string;
+    name: string;
+    /** nullable */
+    phoneCode: string;
+    isCapital: boolean;
+    isActive: boolean;
+    /** nullable -> 0 when unset */
+    lat: number;
+    /** nullable -> 0 when unset */
+    lng: number;
+    hasLat: boolean;
+    hasLng: boolean;
+    /** JSON.stringify(geoJson) or empty */
+    geoJson: string;
+    updatedAt?: Timestamp | undefined;
+    /** nullable */
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoCountryMeta {
+    publicId: string;
+    divisionPublicId: string;
+    /** GeoCountryMeta has no deletedAt in aegis schema. */
+    updatedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoGeoCountryTimezone {
+    publicId: string;
+    countryMetaPublicId: string;
+    timezonePublicId: string;
+    isPrimary: boolean;
+}
+export interface GrpcDtoGeoCountryCurrency {
+    publicId: string;
+    countryMetaPublicId: string;
+    currencyPublicId: string;
+    isPrimary: boolean;
+}
+export interface GrpcDtoGeoCountryLanguage {
+    publicId: string;
+    countryMetaPublicId: string;
+    languagePublicId: string;
+    isOfficial: boolean;
+    isNational: boolean;
+}
+export interface GrpcDtoGeoTimezonesSync {
+    items: GrpcDtoGeoTimezone[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoCurrenciesSync {
+    items: GrpcDtoGeoCurrency[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoLanguagesSync {
+    items: GrpcDtoGeoLanguage[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoLocalesSync {
+    items: GrpcDtoGeoLocale[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoDivisionsSync {
+    items: GrpcDtoGeoDivision[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoCountryMetasSync {
+    items: GrpcDtoGeoCountryMeta[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoCountryTimezonesSync {
+    items: GrpcDtoGeoCountryTimezone[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoCountryCurrenciesSync {
+    items: GrpcDtoGeoCountryCurrency[];
+    nextCursor: string;
+    hasMore: boolean;
+}
+export interface GrpcDtoGeoCountryLanguagesSync {
+    items: GrpcDtoGeoCountryLanguage[];
+    nextCursor: string;
+    hasMore: boolean;
+}
 export interface GrpcDtoPagination {
     totalItems: number;
     totalPages: number;
@@ -23,6 +179,37 @@ export interface GrpcDtoPermission {
 export interface GrpcDtoPermissionsAdd {
     permissions: GrpcDtoPermission[];
 }
+/** ---- CLIENT TYPE ---- */
+export interface GrpcInputClientTypeSeed {
+    name: string;
+}
+export interface GrpcInputClientTypesSeed {
+    clientTypes: GrpcInputClientTypeSeed[];
+}
+export interface GrpcInputClientType {
+    publicId: string;
+}
+export interface GrpcInputClientTypes {
+    search?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcDtoClientType {
+    publicId: string;
+    name: string;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoClientTypesSeed {
+    clientTypes: GrpcDtoClientType[];
+}
+export interface GrpcDtoClientTypes {
+    items: GrpcDtoClientType[];
+    meta?: GrpcDtoPagination | undefined;
+}
 /** ---- FEATURES ---- */
 export interface GrpcInputFeatureSeed {
     name: string;
@@ -76,79 +263,143 @@ export interface GrpcDtoFeaturePermission {
 export interface GrpcDtoFeaturePermissions {
     featurePermissions: GrpcDtoFeaturePermission[];
 }
-/** ---- GEO MESSAGES ---- */
-export interface GrpcDtoGeoDivision {
+/** ---- CLIENT ---- */
+export interface GrpcInputClientCreate {
+    clientTypePublicId: string;
+    name: string;
+    managerPublicId?: string | undefined;
+    description?: string | undefined;
+}
+export interface GrpcInputClientUpdate {
+    publicId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    clientTypePublicId?: string | undefined;
+    managerPublicId?: string | undefined;
+}
+export interface GrpcInputClientFeaturesAdd {
+    publicId: string;
+    featureIds: string[];
+}
+export interface GrpcInputClientFeaturesRemove {
+    publicClientFeatureIds: string[];
+}
+export interface GrpcInputClient {
+    publicId: string;
+}
+export interface GrpcInputClientFeatures {
+    clientPublicId: string;
+}
+export interface GrpcInputClients {
+    clientTypePublicId?: string | undefined;
+    managerPublicId?: string | undefined;
+    search?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcDtoClient {
     publicId: string;
-    /** Parent's public_id; empty string when this is a root division (level 0). */
-    parentPublicId: string;
-    /**
-     * Enum name as string (e.g. "COUNTRY", "REGION") — matches Prisma enum
-     * GEO_DIVISION. Kept as string so adding new levels doesn't require a
-     * proto bump on the subscriber.
-     */
-    type: string;
-    level: number;
-    code: string;
-    /** Immutable hierarchy path (e.g. "KE", "KE.47", "KE.47.001"). */
-    path: string;
     name: string;
-    iso2: string;
-    iso3: string;
-    phoneCode: string;
-    isCapital: boolean;
-    isActive: boolean;
-    /**
-     * Optional centroid. Sent as wrapped/optional so 0,0 stays distinguishable
-     * from "no value". Using `optional` keyword (proto3 field presence).
-     */
-    lat?: number | undefined;
-    lng?: number | undefined;
-    /**
-     * JSON-encoded geometry (GeoJSON). Empty string when not set.
-     * Kept as string to avoid pulling in google.protobuf.Struct here and to
-     * stay lossless for arbitrary GeoJSON shapes.
-     */
-    geoJson: string;
-    /**
-     * Relation references by public_id. Mirrors the structure of aegis
-     * `GeoDivision.timezone` / `.currency` — subscribers can hold either
-     * an opaque string ref or layer their own mirror table on top. We
-     * ship public_ids (not internal ids) so the contract stays portable.
-     */
-    timezonePublicId: string;
-    currencyPublicId: string;
+    description?: string | undefined;
+    clientType?: GrpcDtoClientType | undefined;
     createdAt?: Timestamp | undefined;
     updatedAt?: Timestamp | undefined;
     deletedAt?: Timestamp | undefined;
 }
-export interface GrpcDtoGeoDivisionsPage {
-    items: GrpcDtoGeoDivision[];
-    /** Empty string when there is no next page. */
-    nextCursor: string;
-}
-export interface GrpcDtoGeoDivisions {
-    items: GrpcDtoGeoDivision[];
+export interface GrpcDtoClients {
+    items: GrpcDtoClient[];
+    meta?: GrpcDtoPagination | undefined;
 }
-/** ---- GEO INPUTS ---- */
-export interface GrpcInputGeoDivisionsListAll {
-    /** Empty string means "from the beginning". */
-    cursor: string;
-    /** 0 means "use server default". Server clamps to its max. */
-    limit: number;
+export interface GrpcDtoFeaturesAdd {
+    features: GrpcDtoFeature[];
 }
-export interface GrpcInputGeoDivisionsGetByPublicIds {
-    publicIds: string[];
+export interface GrpcDtoClientFeature {
+    publicId: string;
+    feature?: GrpcDtoFeature | undefined;
+    client?: GrpcDtoClient | undefined;
 }
-export interface GrpcInputGeoDivisionsListChangedSince {
-    /**
-     * Strict `>` comparison server-side. Subscriber should record its
-     * "last seen updated_at" and pass it back here unchanged.
-     */
-    since?: Timestamp | undefined;
-    cursor: string;
-    limit: number;
+export interface GrpcDtoClientFeatures {
+    clientFeatures: GrpcDtoClientFeature[];
 }
 export declare const AEGIS_SYSTEM_V1_PACKAGE_NAME = "aegis.system.v1";
+export declare const GrpcInputGeoSync: {
+    encode(message: GrpcInputGeoSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputGeoSync;
+};
+export declare const GrpcDtoGeoTimezone: {
+    encode(message: GrpcDtoGeoTimezone, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoTimezone;
+};
+export declare const GrpcDtoGeoCurrency: {
+    encode(message: GrpcDtoGeoCurrency, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCurrency;
+};
+export declare const GrpcDtoGeoLanguage: {
+    encode(message: GrpcDtoGeoLanguage, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoLanguage;
+};
+export declare const GrpcDtoGeoLocale: {
+    encode(message: GrpcDtoGeoLocale, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoLocale;
+};
+export declare const GrpcDtoGeoDivision: {
+    encode(message: GrpcDtoGeoDivision, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoDivision;
+};
+export declare const GrpcDtoGeoCountryMeta: {
+    encode(message: GrpcDtoGeoCountryMeta, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryMeta;
+};
+export declare const GrpcDtoGeoCountryTimezone: {
+    encode(message: GrpcDtoGeoCountryTimezone, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryTimezone;
+};
+export declare const GrpcDtoGeoCountryCurrency: {
+    encode(message: GrpcDtoGeoCountryCurrency, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryCurrency;
+};
+export declare const GrpcDtoGeoCountryLanguage: {
+    encode(message: GrpcDtoGeoCountryLanguage, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryLanguage;
+};
+export declare const GrpcDtoGeoTimezonesSync: {
+    encode(message: GrpcDtoGeoTimezonesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoTimezonesSync;
+};
+export declare const GrpcDtoGeoCurrenciesSync: {
+    encode(message: GrpcDtoGeoCurrenciesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCurrenciesSync;
+};
+export declare const GrpcDtoGeoLanguagesSync: {
+    encode(message: GrpcDtoGeoLanguagesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoLanguagesSync;
+};
+export declare const GrpcDtoGeoLocalesSync: {
+    encode(message: GrpcDtoGeoLocalesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoLocalesSync;
+};
+export declare const GrpcDtoGeoDivisionsSync: {
+    encode(message: GrpcDtoGeoDivisionsSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoDivisionsSync;
+};
+export declare const GrpcDtoGeoCountryMetasSync: {
+    encode(message: GrpcDtoGeoCountryMetasSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryMetasSync;
+};
+export declare const GrpcDtoGeoCountryTimezonesSync: {
+    encode(message: GrpcDtoGeoCountryTimezonesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryTimezonesSync;
+};
+export declare const GrpcDtoGeoCountryCurrenciesSync: {
+    encode(message: GrpcDtoGeoCountryCurrenciesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryCurrenciesSync;
+};
+export declare const GrpcDtoGeoCountryLanguagesSync: {
+    encode(message: GrpcDtoGeoCountryLanguagesSync, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoCountryLanguagesSync;
+};
 export declare const GrpcDtoPagination: {
     encode(message: GrpcDtoPagination, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPagination;
@@ -165,6 +416,34 @@ export declare const GrpcDtoPermissionsAdd: {
     encode(message: GrpcDtoPermissionsAdd, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPermissionsAdd;
 };
+export declare const GrpcInputClientTypeSeed: {
+    encode(message: GrpcInputClientTypeSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypeSeed;
+};
+export declare const GrpcInputClientTypesSeed: {
+    encode(message: GrpcInputClientTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypesSeed;
+};
+export declare const GrpcInputClientType: {
+    encode(message: GrpcInputClientType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientType;
+};
+export declare const GrpcInputClientTypes: {
+    encode(message: GrpcInputClientTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypes;
+};
+export declare const GrpcDtoClientType: {
+    encode(message: GrpcDtoClientType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientType;
+};
+export declare const GrpcDtoClientTypesSeed: {
+    encode(message: GrpcDtoClientTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientTypesSeed;
+};
+export declare const GrpcDtoClientTypes: {
+    encode(message: GrpcDtoClientTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientTypes;
+};
 export declare const GrpcInputFeatureSeed: {
     encode(message: GrpcInputFeatureSeed, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputFeatureSeed;
@@ -213,31 +492,59 @@ export declare const GrpcDtoFeaturePermissions: {
     encode(message: GrpcDtoFeaturePermissions, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoFeaturePermissions;
 };
-export declare const GrpcDtoGeoDivision: {
-    encode(message: GrpcDtoGeoDivision, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoDivision;
+export declare const GrpcInputClientCreate: {
+    encode(message: GrpcInputClientCreate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientCreate;
+};
+export declare const GrpcInputClientUpdate: {
+    encode(message: GrpcInputClientUpdate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientUpdate;
 };
-export declare const GrpcDtoGeoDivisionsPage: {
-    encode(message: GrpcDtoGeoDivisionsPage, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoDivisionsPage;
+export declare const GrpcInputClientFeaturesAdd: {
+    encode(message: GrpcInputClientFeaturesAdd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientFeaturesAdd;
 };
-export declare const GrpcDtoGeoDivisions: {
-    encode(message: GrpcDtoGeoDivisions, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoGeoDivisions;
+export declare const GrpcInputClientFeaturesRemove: {
+    encode(message: GrpcInputClientFeaturesRemove, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientFeaturesRemove;
 };
-export declare const GrpcInputGeoDivisionsListAll: {
-    encode(message: GrpcInputGeoDivisionsListAll, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputGeoDivisionsListAll;
+export declare const GrpcInputClient: {
+    encode(message: GrpcInputClient, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClient;
 };
-export declare const GrpcInputGeoDivisionsGetByPublicIds: {
-    encode(message: GrpcInputGeoDivisionsGetByPublicIds, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputGeoDivisionsGetByPublicIds;
+export declare const GrpcInputClientFeatures: {
+    encode(message: GrpcInputClientFeatures, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientFeatures;
 };
-export declare const GrpcInputGeoDivisionsListChangedSince: {
-    encode(message: GrpcInputGeoDivisionsListChangedSince, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputGeoDivisionsListChangedSince;
+export declare const GrpcInputClients: {
+    encode(message: GrpcInputClients, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClients;
+};
+export declare const GrpcDtoClient: {
+    encode(message: GrpcDtoClient, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClient;
+};
+export declare const GrpcDtoClients: {
+    encode(message: GrpcDtoClients, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClients;
+};
+export declare const GrpcDtoFeaturesAdd: {
+    encode(message: GrpcDtoFeaturesAdd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoFeaturesAdd;
+};
+export declare const GrpcDtoClientFeature: {
+    encode(message: GrpcDtoClientFeature, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientFeature;
+};
+export declare const GrpcDtoClientFeatures: {
+    encode(message: GrpcDtoClientFeatures, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientFeatures;
 };
 export interface SystemServiceClient {
+    /** --- Client Types --- */
+    clientTypesSeed(request: GrpcInputClientTypesSeed): Observable<GrpcDtoClientTypesSeed>;
+    clientTypes(request: GrpcInputClientTypes): Observable<GrpcDtoClientTypes>;
+    clientType(request: GrpcInputClientType): Observable<GrpcDtoClientType>;
     /** --- Features --- */
     featuresSeed(request: GrpcInputFeaturesSeed): Observable<GrpcDtoFeaturesSeed>;
     features(request: GrpcInputFeatures): Observable<GrpcDtoFeatures>;
@@ -245,8 +552,30 @@ export interface SystemServiceClient {
     featurePermissions(request: GrpcInputFeaturePermissions): Observable<GrpcDtoFeaturePermissions>;
     featurePermissionsAdd(request: GrpcInputFeaturePermissionsAdd): Observable<GrpcDtoPermissionsAdd>;
     featurePermissionsRemove(request: GrpcInputFeaturePermissionsRemove): Observable<GrpcDtoMessage>;
+    /** --- Clients --- */
+    clientCreate(request: GrpcInputClientCreate): Observable<GrpcDtoClient>;
+    clientUpdate(request: GrpcInputClientUpdate): Observable<GrpcDtoClient>;
+    clients(request: GrpcInputClients): Observable<GrpcDtoClients>;
+    client(request: GrpcInputClient): Observable<GrpcDtoClient>;
+    clientFeaturesAdd(request: GrpcInputClientFeaturesAdd): Observable<GrpcDtoFeaturesAdd>;
+    clientFeaturesRemove(request: GrpcInputClientFeaturesRemove): Observable<GrpcDtoMessage>;
+    clientFeatures(request: GrpcInputClientFeatures): Observable<GrpcDtoClientFeatures>;
+    /** --- Geo delta sync (hourly pull from gtms mirror) --- */
+    geoTimezonesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoTimezonesSync>;
+    geoCurrenciesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoCurrenciesSync>;
+    geoLanguagesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoLanguagesSync>;
+    geoLocalesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoLocalesSync>;
+    geoDivisionsSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoDivisionsSync>;
+    geoCountryMetasSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoCountryMetasSync>;
+    geoCountryTimezonesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoCountryTimezonesSync>;
+    geoCountryCurrenciesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoCountryCurrenciesSync>;
+    geoCountryLanguagesSync(request: GrpcInputGeoSync): Observable<GrpcDtoGeoCountryLanguagesSync>;
 }
 export interface SystemServiceController {
+    /** --- Client Types --- */
+    clientTypesSeed(request: GrpcInputClientTypesSeed): Promise<GrpcDtoClientTypesSeed> | Observable<GrpcDtoClientTypesSeed> | GrpcDtoClientTypesSeed;
+    clientTypes(request: GrpcInputClientTypes): Promise<GrpcDtoClientTypes> | Observable<GrpcDtoClientTypes> | GrpcDtoClientTypes;
+    clientType(request: GrpcInputClientType): Promise<GrpcDtoClientType> | Observable<GrpcDtoClientType> | GrpcDtoClientType;
     /** --- Features --- */
     featuresSeed(request: GrpcInputFeaturesSeed): Promise<GrpcDtoFeaturesSeed> | Observable<GrpcDtoFeaturesSeed> | GrpcDtoFeaturesSeed;
     features(request: GrpcInputFeatures): Promise<GrpcDtoFeatures> | Observable<GrpcDtoFeatures> | GrpcDtoFeatures;
@@ -254,11 +583,57 @@ export interface SystemServiceController {
     featurePermissions(request: GrpcInputFeaturePermissions): Promise<GrpcDtoFeaturePermissions> | Observable<GrpcDtoFeaturePermissions> | GrpcDtoFeaturePermissions;
     featurePermissionsAdd(request: GrpcInputFeaturePermissionsAdd): Promise<GrpcDtoPermissionsAdd> | Observable<GrpcDtoPermissionsAdd> | GrpcDtoPermissionsAdd;
     featurePermissionsRemove(request: GrpcInputFeaturePermissionsRemove): Promise<GrpcDtoMessage> | Observable<GrpcDtoMessage> | GrpcDtoMessage;
+    /** --- Clients --- */
+    clientCreate(request: GrpcInputClientCreate): Promise<GrpcDtoClient> | Observable<GrpcDtoClient> | GrpcDtoClient;
+    clientUpdate(request: GrpcInputClientUpdate): Promise<GrpcDtoClient> | Observable<GrpcDtoClient> | GrpcDtoClient;
+    clients(request: GrpcInputClients): Promise<GrpcDtoClients> | Observable<GrpcDtoClients> | GrpcDtoClients;
+    client(request: GrpcInputClient): Promise<GrpcDtoClient> | Observable<GrpcDtoClient> | GrpcDtoClient;
+    clientFeaturesAdd(request: GrpcInputClientFeaturesAdd): Promise<GrpcDtoFeaturesAdd> | Observable<GrpcDtoFeaturesAdd> | GrpcDtoFeaturesAdd;
+    clientFeaturesRemove(request: GrpcInputClientFeaturesRemove): Promise<GrpcDtoMessage> | Observable<GrpcDtoMessage> | GrpcDtoMessage;
+    clientFeatures(request: GrpcInputClientFeatures): Promise<GrpcDtoClientFeatures> | Observable<GrpcDtoClientFeatures> | GrpcDtoClientFeatures;
+    /** --- Geo delta sync (hourly pull from gtms mirror) --- */
+    geoTimezonesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoTimezonesSync> | Observable<GrpcDtoGeoTimezonesSync> | GrpcDtoGeoTimezonesSync;
+    geoCurrenciesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoCurrenciesSync> | Observable<GrpcDtoGeoCurrenciesSync> | GrpcDtoGeoCurrenciesSync;
+    geoLanguagesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoLanguagesSync> | Observable<GrpcDtoGeoLanguagesSync> | GrpcDtoGeoLanguagesSync;
+    geoLocalesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoLocalesSync> | Observable<GrpcDtoGeoLocalesSync> | GrpcDtoGeoLocalesSync;
+    geoDivisionsSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoDivisionsSync> | Observable<GrpcDtoGeoDivisionsSync> | GrpcDtoGeoDivisionsSync;
+    geoCountryMetasSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoCountryMetasSync> | Observable<GrpcDtoGeoCountryMetasSync> | GrpcDtoGeoCountryMetasSync;
+    geoCountryTimezonesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoCountryTimezonesSync> | Observable<GrpcDtoGeoCountryTimezonesSync> | GrpcDtoGeoCountryTimezonesSync;
+    geoCountryCurrenciesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoCountryCurrenciesSync> | Observable<GrpcDtoGeoCountryCurrenciesSync> | GrpcDtoGeoCountryCurrenciesSync;
+    geoCountryLanguagesSync(request: GrpcInputGeoSync): Promise<GrpcDtoGeoCountryLanguagesSync> | Observable<GrpcDtoGeoCountryLanguagesSync> | GrpcDtoGeoCountryLanguagesSync;
 }
 export declare function SystemServiceControllerMethods(): (constructor: Function) => void;
 export declare const SYSTEM_SERVICE_NAME = "SystemService";
 export type SystemServiceService = typeof SystemServiceService;
 export declare const SystemServiceService: {
+    /** --- Client Types --- */
+    readonly clientTypesSeed: {
+        readonly path: "/aegis.system.v1.SystemService/ClientTypesSeed";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientTypesSeed) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientTypesSeed;
+        readonly responseSerialize: (value: GrpcDtoClientTypesSeed) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientTypesSeed;
+    };
+    readonly clientTypes: {
+        readonly path: "/aegis.system.v1.SystemService/ClientTypes";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientTypes) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientTypes;
+        readonly responseSerialize: (value: GrpcDtoClientTypes) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientTypes;
+    };
+    readonly clientType: {
+        readonly path: "/aegis.system.v1.SystemService/ClientType";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientType) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientType;
+        readonly responseSerialize: (value: GrpcDtoClientType) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientType;
+    };
     /** --- Features --- */
     readonly featuresSeed: {
         readonly path: "/aegis.system.v1.SystemService/FeaturesSeed";
@@ -314,88 +689,182 @@ export declare const SystemServiceService: {
         readonly responseSerialize: (value: GrpcDtoMessage) => Buffer<ArrayBuffer>;
         readonly responseDeserialize: (value: Buffer) => GrpcDtoMessage;
     };
-};
-export interface SystemServiceServer extends UntypedServiceImplementation {
-    /** --- Features --- */
-    featuresSeed: handleUnaryCall<GrpcInputFeaturesSeed, GrpcDtoFeaturesSeed>;
-    features: handleUnaryCall<GrpcInputFeatures, GrpcDtoFeatures>;
-    feature: handleUnaryCall<GrpcInputFeature, GrpcDtoFeature>;
-    featurePermissions: handleUnaryCall<GrpcInputFeaturePermissions, GrpcDtoFeaturePermissions>;
-    featurePermissionsAdd: handleUnaryCall<GrpcInputFeaturePermissionsAdd, GrpcDtoPermissionsAdd>;
-    featurePermissionsRemove: handleUnaryCall<GrpcInputFeaturePermissionsRemove, GrpcDtoMessage>;
-}
-/** ---- GEO SERVICE ---- */
-export interface GeoServiceClient {
-    /** Full sync (used on first mirror boot). Paged by public_id cursor. */
-    geoDivisionsListAll(request: GrpcInputGeoDivisionsListAll): Observable<GrpcDtoGeoDivisionsPage>;
-    /** Batch fetch by public_id (used by live Redis event consumers). */
-    geoDivisionsGetByPublicIds(request: GrpcInputGeoDivisionsGetByPublicIds): Observable<GrpcDtoGeoDivisions>;
-    /**
-     * Hourly safety-net reconciler. Catches anything the Redis publisher
-     * dropped due to restart races.
-     */
-    geoDivisionsListChangedSince(request: GrpcInputGeoDivisionsListChangedSince): Observable<GrpcDtoGeoDivisionsPage>;
-}
-/** ---- GEO SERVICE ---- */
-export interface GeoServiceController {
-    /** Full sync (used on first mirror boot). Paged by public_id cursor. */
-    geoDivisionsListAll(request: GrpcInputGeoDivisionsListAll): Promise<GrpcDtoGeoDivisionsPage> | Observable<GrpcDtoGeoDivisionsPage> | GrpcDtoGeoDivisionsPage;
-    /** Batch fetch by public_id (used by live Redis event consumers). */
-    geoDivisionsGetByPublicIds(request: GrpcInputGeoDivisionsGetByPublicIds): Promise<GrpcDtoGeoDivisions> | Observable<GrpcDtoGeoDivisions> | GrpcDtoGeoDivisions;
-    /**
-     * Hourly safety-net reconciler. Catches anything the Redis publisher
-     * dropped due to restart races.
-     */
-    geoDivisionsListChangedSince(request: GrpcInputGeoDivisionsListChangedSince): Promise<GrpcDtoGeoDivisionsPage> | Observable<GrpcDtoGeoDivisionsPage> | GrpcDtoGeoDivisionsPage;
-}
-export declare function GeoServiceControllerMethods(): (constructor: Function) => void;
-export declare const GEO_SERVICE_NAME = "GeoService";
-/** ---- GEO SERVICE ---- */
-export type GeoServiceService = typeof GeoServiceService;
-export declare const GeoServiceService: {
-    /** Full sync (used on first mirror boot). Paged by public_id cursor. */
-    readonly geoDivisionsListAll: {
-        readonly path: "/aegis.system.v1.GeoService/GeoDivisionsListAll";
+    /** --- Clients --- */
+    readonly clientCreate: {
+        readonly path: "/aegis.system.v1.SystemService/ClientCreate";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: GrpcInputGeoDivisionsListAll) => Buffer<ArrayBuffer>;
-        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoDivisionsListAll;
-        readonly responseSerialize: (value: GrpcDtoGeoDivisionsPage) => Buffer<ArrayBuffer>;
-        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoDivisionsPage;
+        readonly requestSerialize: (value: GrpcInputClientCreate) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientCreate;
+        readonly responseSerialize: (value: GrpcDtoClient) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClient;
     };
-    /** Batch fetch by public_id (used by live Redis event consumers). */
-    readonly geoDivisionsGetByPublicIds: {
-        readonly path: "/aegis.system.v1.GeoService/GeoDivisionsGetByPublicIds";
+    readonly clientUpdate: {
+        readonly path: "/aegis.system.v1.SystemService/ClientUpdate";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: GrpcInputGeoDivisionsGetByPublicIds) => Buffer<ArrayBuffer>;
-        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoDivisionsGetByPublicIds;
-        readonly responseSerialize: (value: GrpcDtoGeoDivisions) => Buffer<ArrayBuffer>;
-        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoDivisions;
+        readonly requestSerialize: (value: GrpcInputClientUpdate) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientUpdate;
+        readonly responseSerialize: (value: GrpcDtoClient) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClient;
     };
-    /**
-     * Hourly safety-net reconciler. Catches anything the Redis publisher
-     * dropped due to restart races.
-     */
-    readonly geoDivisionsListChangedSince: {
-        readonly path: "/aegis.system.v1.GeoService/GeoDivisionsListChangedSince";
+    readonly clients: {
+        readonly path: "/aegis.system.v1.SystemService/Clients";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClients) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClients;
+        readonly responseSerialize: (value: GrpcDtoClients) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClients;
+    };
+    readonly client: {
+        readonly path: "/aegis.system.v1.SystemService/Client";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: GrpcInputGeoDivisionsListChangedSince) => Buffer<ArrayBuffer>;
-        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoDivisionsListChangedSince;
-        readonly responseSerialize: (value: GrpcDtoGeoDivisionsPage) => Buffer<ArrayBuffer>;
-        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoDivisionsPage;
+        readonly requestSerialize: (value: GrpcInputClient) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClient;
+        readonly responseSerialize: (value: GrpcDtoClient) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClient;
+    };
+    readonly clientFeaturesAdd: {
+        readonly path: "/aegis.system.v1.SystemService/ClientFeaturesAdd";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientFeaturesAdd) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientFeaturesAdd;
+        readonly responseSerialize: (value: GrpcDtoFeaturesAdd) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoFeaturesAdd;
+    };
+    readonly clientFeaturesRemove: {
+        readonly path: "/aegis.system.v1.SystemService/ClientFeaturesRemove";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientFeaturesRemove) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientFeaturesRemove;
+        readonly responseSerialize: (value: GrpcDtoMessage) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoMessage;
+    };
+    readonly clientFeatures: {
+        readonly path: "/aegis.system.v1.SystemService/ClientFeatures";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientFeatures) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientFeatures;
+        readonly responseSerialize: (value: GrpcDtoClientFeatures) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientFeatures;
+    };
+    /** --- Geo delta sync (hourly pull from gtms mirror) --- */
+    readonly geoTimezonesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoTimezonesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoTimezonesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoTimezonesSync;
+    };
+    readonly geoCurrenciesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoCurrenciesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoCurrenciesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoCurrenciesSync;
+    };
+    readonly geoLanguagesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoLanguagesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoLanguagesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoLanguagesSync;
+    };
+    readonly geoLocalesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoLocalesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoLocalesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoLocalesSync;
+    };
+    readonly geoDivisionsSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoDivisionsSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoDivisionsSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoDivisionsSync;
+    };
+    readonly geoCountryMetasSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoCountryMetasSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoCountryMetasSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoCountryMetasSync;
+    };
+    readonly geoCountryTimezonesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoCountryTimezonesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoCountryTimezonesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoCountryTimezonesSync;
+    };
+    readonly geoCountryCurrenciesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoCountryCurrenciesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoCountryCurrenciesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoCountryCurrenciesSync;
+    };
+    readonly geoCountryLanguagesSync: {
+        readonly path: "/aegis.system.v1.SystemService/GeoCountryLanguagesSync";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputGeoSync) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputGeoSync;
+        readonly responseSerialize: (value: GrpcDtoGeoCountryLanguagesSync) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoGeoCountryLanguagesSync;
     };
 };
-export interface GeoServiceServer extends UntypedServiceImplementation {
-    /** Full sync (used on first mirror boot). Paged by public_id cursor. */
-    geoDivisionsListAll: handleUnaryCall<GrpcInputGeoDivisionsListAll, GrpcDtoGeoDivisionsPage>;
-    /** Batch fetch by public_id (used by live Redis event consumers). */
-    geoDivisionsGetByPublicIds: handleUnaryCall<GrpcInputGeoDivisionsGetByPublicIds, GrpcDtoGeoDivisions>;
-    /**
-     * Hourly safety-net reconciler. Catches anything the Redis publisher
-     * dropped due to restart races.
-     */
-    geoDivisionsListChangedSince: handleUnaryCall<GrpcInputGeoDivisionsListChangedSince, GrpcDtoGeoDivisionsPage>;
+export interface SystemServiceServer extends UntypedServiceImplementation {
+    /** --- Client Types --- */
+    clientTypesSeed: handleUnaryCall<GrpcInputClientTypesSeed, GrpcDtoClientTypesSeed>;
+    clientTypes: handleUnaryCall<GrpcInputClientTypes, GrpcDtoClientTypes>;
+    clientType: handleUnaryCall<GrpcInputClientType, GrpcDtoClientType>;
+    /** --- Features --- */
+    featuresSeed: handleUnaryCall<GrpcInputFeaturesSeed, GrpcDtoFeaturesSeed>;
+    features: handleUnaryCall<GrpcInputFeatures, GrpcDtoFeatures>;
+    feature: handleUnaryCall<GrpcInputFeature, GrpcDtoFeature>;
+    featurePermissions: handleUnaryCall<GrpcInputFeaturePermissions, GrpcDtoFeaturePermissions>;
+    featurePermissionsAdd: handleUnaryCall<GrpcInputFeaturePermissionsAdd, GrpcDtoPermissionsAdd>;
+    featurePermissionsRemove: handleUnaryCall<GrpcInputFeaturePermissionsRemove, GrpcDtoMessage>;
+    /** --- Clients --- */
+    clientCreate: handleUnaryCall<GrpcInputClientCreate, GrpcDtoClient>;
+    clientUpdate: handleUnaryCall<GrpcInputClientUpdate, GrpcDtoClient>;
+    clients: handleUnaryCall<GrpcInputClients, GrpcDtoClients>;
+    client: handleUnaryCall<GrpcInputClient, GrpcDtoClient>;
+    clientFeaturesAdd: handleUnaryCall<GrpcInputClientFeaturesAdd, GrpcDtoFeaturesAdd>;
+    clientFeaturesRemove: handleUnaryCall<GrpcInputClientFeaturesRemove, GrpcDtoMessage>;
+    clientFeatures: handleUnaryCall<GrpcInputClientFeatures, GrpcDtoClientFeatures>;
+    /** --- Geo delta sync (hourly pull from gtms mirror) --- */
+    geoTimezonesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoTimezonesSync>;
+    geoCurrenciesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoCurrenciesSync>;
+    geoLanguagesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoLanguagesSync>;
+    geoLocalesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoLocalesSync>;
+    geoDivisionsSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoDivisionsSync>;
+    geoCountryMetasSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoCountryMetasSync>;
+    geoCountryTimezonesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoCountryTimezonesSync>;
+    geoCountryCurrenciesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoCountryCurrenciesSync>;
+    geoCountryLanguagesSync: handleUnaryCall<GrpcInputGeoSync, GrpcDtoGeoCountryLanguagesSync>;
 }
 //# sourceMappingURL=system.d.ts.map