@serve.zone/interfaces 22.0.0 → 23.0.1

package/ts/runtime.ts

@@ -1,80 +1,353 @@
-import type * as plugins from './plugins.js';
+import * as plugins from './plugins.js';
 import type {
   IIdentityCredential,
   IResolvedSecretManifest,
   TSha256Digest,
+  TSecretRecipientMetadata,
 } from './data/index.js';
 import {
+  createResolvedSecretMaterialEnvelopeContext,
+  createSecretRecipientEnrollmentChallengeContext,
   validateResolvedSecretManifest,
+  validateSecretRecipientMetadata,
+  verifySecretEnvelopeContext,
   verifyResolvedSecretManifestDigest,
 } from './data/secret.js';
 
-/**
- * Runtime-only material. This module is exported only under the Node condition
- * and is intentionally unreachable from the universal/browser-facing barrel.
- */
-export interface IResolvedSecretMaterialValue {
+export interface ISealedResolvedSecretMaterialEntry {
   secretVersionId: string;
-  value: string;
+  envelope: plugins.smartcrypto.IX25519EnvelopeV1;
 }
 
-export interface IResolvedSecretMaterial {
+/** Runtime-only material. No plaintext value is represented in this DTO. */
+export interface ISealedResolvedSecretMaterial {
   schemaVersion: 1;
-  /** Full value-free manifest so the runtime can verify its canonical digest. */
+  /** Full schema-v2 value-free manifest used for digest and rollout verification. */
   manifest: IResolvedSecretManifest;
-  /** Plaintext values keyed only by the exact version IDs pinned by the manifest. */
-  values: IResolvedSecretMaterialValue[];
+  /** Sorted exact coverage of the manifest's pinned versions. */
+  entries: ISealedResolvedSecretMaterialEntry[];
+}
+
+export interface ISecretMaterialRequestFence {
+  serviceId: string;
+  imageRolloutId: string;
+  imageRolloutGeneration: number;
+  requestedImageDigest: TSha256Digest;
+  secretRolloutId: string;
+  secretRolloutGeneration: number;
+  manifestId: string;
+  manifestDigest: TSha256Digest;
+  expectedRecipientKeyId: string;
+}
+
+/** Request fence plus trusted local scope derived from the verified cluster identity. */
+export interface ISecretMaterialExpectation
+extends ISecretMaterialRequestFence {
+  organizationId: string;
+  clusterId: string;
 }
 
 /**
- * Verifies the immutable manifest and requires exactly one material value for
- * every pinned version. Callers separately compare the verified manifest
- * reference to the request and their authenticated cluster scope.
+ * Parses every envelope with SmartCrypto, verifies its bound context digest,
+ * and checks sorted exact version coverage. It never receives a private key
+ * and never decrypts material.
  */
-export const verifyResolvedSecretMaterial = async (
+export const verifySealedResolvedSecretMaterial = async (
   materialArg: unknown,
+  expectedArg: ISecretMaterialExpectation,
 ): Promise<boolean> => {
   if (!materialArg || typeof materialArg !== 'object' || Array.isArray(materialArg)) return false;
-  const material = materialArg as Partial<IResolvedSecretMaterial>;
-  if (!material.manifest || !Array.isArray(material.values)) return false;
-  if (material.schemaVersion !== 1) return false;
-  if (validateResolvedSecretManifest(material.manifest).length > 0) return false;
-  if (!await verifyResolvedSecretManifestDigest(material.manifest)) return false;
-  if (!material.values.every((valueArg) => (
-    Boolean(valueArg)
-    && typeof valueArg === 'object'
-    && typeof valueArg.secretVersionId === 'string'
-    && typeof valueArg.value === 'string'
-  ))) return false;
+  const material = materialArg as Partial<ISealedResolvedSecretMaterial>;
+  if (JSON.stringify(Object.keys(material).sort()) !== JSON.stringify([
+    'entries',
+    'manifest',
+    'schemaVersion',
+  ])) {
+    return false;
+  }
+  if (material.schemaVersion !== 1 || !material.manifest || !Array.isArray(material.entries)) {
+    return false;
+  }
+  if (validateResolvedSecretManifest(material.manifest).length > 0
+    || !await verifyResolvedSecretManifestDigest(material.manifest)) {
+    return false;
+  }
+  if (material.manifest.organizationId !== expectedArg.organizationId
+    || material.manifest.clusterId !== expectedArg.clusterId
+    || material.manifest.serviceId !== expectedArg.serviceId
+    || material.manifest.imageRolloutId !== expectedArg.imageRolloutId
+    || material.manifest.imageRolloutGeneration !== expectedArg.imageRolloutGeneration
+    || material.manifest.requestedImageDigest !== expectedArg.requestedImageDigest
+    || material.manifest.secretRolloutId !== expectedArg.secretRolloutId
+    || material.manifest.secretRolloutGeneration !== expectedArg.secretRolloutGeneration
+    || material.manifest.id !== expectedArg.manifestId
+    || material.manifest.digest !== expectedArg.manifestDigest) {
+    return false;
+  }
+  if (material.entries.length > 256
+    || material.entries.length !== material.manifest.entries.length) {
+    return false;
+  }
   const expectedVersionIds = material.manifest.entries
     .map((entryArg) => entryArg.secretVersionId)
     .sort();
-  const actualVersionIds = material.values
-    .map((valueArg) => valueArg.secretVersionId)
-    .sort();
-  return new Set(actualVersionIds).size === actualVersionIds.length
-    && JSON.stringify(actualVersionIds) === JSON.stringify(expectedVersionIds);
+  const actualVersionIds = material.entries.map((entryArg) => entryArg.secretVersionId);
+  if (new Set(actualVersionIds).size !== actualVersionIds.length
+    || JSON.stringify(actualVersionIds) !== JSON.stringify(expectedVersionIds)) {
+    return false;
+  }
+  const manifestEntriesByVersion = new Map(material.manifest.entries.map((entryArg) => [
+    entryArg.secretVersionId,
+    entryArg,
+  ]));
+  for (const entry of material.entries) {
+    if (!entry || typeof entry !== 'object' || typeof entry.secretVersionId !== 'string') return false;
+    if (JSON.stringify(Object.keys(entry).sort()) !== JSON.stringify([
+      'envelope',
+      'secretVersionId',
+    ])) {
+      return false;
+    }
+    const manifestEntry = manifestEntriesByVersion.get(entry.secretVersionId);
+    if (!manifestEntry) return false;
+    let envelope: plugins.smartcrypto.IX25519EnvelopeV1;
+    try {
+      envelope = plugins.smartcrypto.parseX25519Envelope(entry.envelope);
+    } catch {
+      return false;
+    }
+    if (envelope.recipientKeyId !== expectedArg.expectedRecipientKeyId) return false;
+    const context = createResolvedSecretMaterialEnvelopeContext({
+      recipientKeyId: expectedArg.expectedRecipientKeyId,
+      organizationId: material.manifest.organizationId,
+      clusterId: material.manifest.clusterId,
+      serviceId: material.manifest.serviceId,
+      imageRolloutId: material.manifest.imageRolloutId,
+      imageRolloutGeneration: material.manifest.imageRolloutGeneration,
+      requestedImageDigest: material.manifest.requestedImageDigest,
+      secretRolloutId: material.manifest.secretRolloutId,
+      secretRolloutGeneration: material.manifest.secretRolloutGeneration,
+      manifestId: material.manifest.id,
+      manifestDigest: material.manifest.digest,
+      secretId: manifestEntry.secretId,
+      secretVersionId: manifestEntry.secretVersionId,
+    });
+    if (!await verifySecretEnvelopeContext(envelope, context)) return false;
+  }
+  return true;
 };
 
-/**
- * Cluster and organization are derived from the verified JWT. A caller cannot
- * select either scope through request fields.
- */
+/** Organization and cluster are derived exclusively from the verified cluster JWT. */
 export interface IReq_GetResolvedSecretMaterial
 extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
   IReq_GetResolvedSecretMaterial
 > {
   method: 'getResolvedSecretMaterial';
+  request: ISecretMaterialRequestFence & {
+    identity: IIdentityCredential;
+  };
+  response: {
+    material: ISealedResolvedSecretMaterial;
+  };
+}
+
+export interface ISecretRecipientEnrollmentChallengeV1 {
+  schemaVersion: 1;
+  enrollmentId: string;
+  clusterId: string;
+  recipientKeyId: string;
+  publicKey: string;
+  generation: number;
+  expiresAt: number;
+  /** Sealed random 32-byte challenge; plaintext is never persisted or returned. */
+  envelope: plugins.smartcrypto.IX25519EnvelopeV1;
+}
+
+/**
+ * Cluster scope is derived from the JWT. The server persists only a one-time
+ * challenge hash plus expiry and consumes it with generation CAS; reuse,
+ * expiry, mismatch, and replay are rejected. Private keys and challenge
+ * plaintext have no persistence DTO.
+ */
+export interface IReq_BeginSecretRecipientEnrollment
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_BeginSecretRecipientEnrollment
+> {
+  method: 'beginSecretRecipientEnrollment';
+  request: {
+    identity: IIdentityCredential;
+    proposedRecipientKeyId: string;
+    proposedPublicKey: string;
+    expectedGeneration: number;
+  };
+  response: {
+    challenge: ISecretRecipientEnrollmentChallengeV1;
+  };
+}
+
+export interface IReq_CompleteSecretRecipientEnrollment
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_CompleteSecretRecipientEnrollment
+> {
+  method: 'completeSecretRecipientEnrollment';
   request: {
     identity: IIdentityCredential;
-    serviceId: string;
-    secretRolloutId: string;
-    secretRolloutGeneration: number;
-    manifestId: string;
-    manifestDigest: TSha256Digest;
+    enrollmentId: string;
+    expectedGeneration: number;
+    /** Canonical unpadded base64url response containing exactly 32 bytes. */
+    response: string;
   };
   response: {
-    material: IResolvedSecretMaterial;
+    recipient: TSecretRecipientMetadata;
   };
 }
+
+const canonicalIdentifierRegex = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+const raw32ByteBase64UrlRegex = /^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/;
+
+export const validateBeginSecretRecipientEnrollmentRequest = (
+  requestArg: unknown,
+): string[] => {
+  if (!requestArg || typeof requestArg !== 'object' || Array.isArray(requestArg)) {
+    return ['enrollment request must be an object'];
+  }
+  const request = requestArg as Record<string, unknown>;
+  const errors: string[] = [];
+  if (JSON.stringify(Object.keys(request).sort()) !== JSON.stringify([
+    'expectedGeneration',
+    'identity',
+    'proposedPublicKey',
+    'proposedRecipientKeyId',
+  ])) {
+    errors.push('enrollment request must use its exact schema');
+  }
+  if (!request.identity || typeof request.identity !== 'object'
+    || typeof (request.identity as Record<string, unknown>).jwt !== 'string') {
+    errors.push('enrollment identity must be a JWT credential');
+  }
+  if (typeof request.proposedRecipientKeyId !== 'string'
+    || !canonicalIdentifierRegex.test(request.proposedRecipientKeyId)) {
+    errors.push('proposed recipient key id must be canonical');
+  }
+  if (typeof request.proposedPublicKey !== 'string'
+    || !raw32ByteBase64UrlRegex.test(request.proposedPublicKey)) {
+    errors.push('proposed public key must be canonical base64url raw X25519 material');
+  }
+  if (!Number.isSafeInteger(request.expectedGeneration)
+    || (request.expectedGeneration as number) < 0) {
+    errors.push('expected generation must be a non-negative integer');
+  }
+  if ('clusterId' in request || 'organizationId' in request) {
+    errors.push('enrollment request must not select cluster or organization scope');
+  }
+  return errors;
+};
+
+export const validateSecretRecipientEnrollmentChallenge = async (
+  challengeArg: unknown,
+): Promise<string[]> => {
+  if (!challengeArg || typeof challengeArg !== 'object' || Array.isArray(challengeArg)) {
+    return ['enrollment challenge must be an object'];
+  }
+  const challenge = challengeArg as Record<string, unknown>;
+  const errors: string[] = [];
+  if (JSON.stringify(Object.keys(challenge).sort()) !== JSON.stringify([
+    'clusterId',
+    'enrollmentId',
+    'envelope',
+    'expiresAt',
+    'generation',
+    'publicKey',
+    'recipientKeyId',
+    'schemaVersion',
+  ])) {
+    errors.push('enrollment challenge must use its exact schema');
+  }
+  for (const field of ['enrollmentId', 'clusterId', 'recipientKeyId'] as const) {
+    if (typeof challenge[field] !== 'string'
+      || !canonicalIdentifierRegex.test(challenge[field] as string)) {
+      errors.push(`enrollment challenge ${field} must be canonical`);
+    }
+  }
+  if (challenge.schemaVersion !== 1) errors.push('enrollment challenge schemaVersion must be 1');
+  if (typeof challenge.publicKey !== 'string'
+    || !raw32ByteBase64UrlRegex.test(challenge.publicKey)) {
+    errors.push('enrollment challenge public key must be canonical');
+  }
+  if (!Number.isSafeInteger(challenge.generation) || (challenge.generation as number) < 1) {
+    errors.push('enrollment challenge generation must be positive');
+  }
+  if (!Number.isSafeInteger(challenge.expiresAt) || (challenge.expiresAt as number) < 1) {
+    errors.push('enrollment challenge expiry must be positive');
+  }
+  let envelope: plugins.smartcrypto.IX25519EnvelopeV1 | undefined;
+  try {
+    envelope = plugins.smartcrypto.parseX25519Envelope(challenge.envelope);
+  } catch {
+    errors.push('enrollment challenge envelope must be strict');
+  }
+  if (envelope) {
+    if (envelope.recipientKeyId !== challenge.recipientKeyId) {
+      errors.push('enrollment challenge recipient does not match');
+    }
+    if (!raw32ByteBase64UrlRegex.test(envelope.ciphertext)) {
+      errors.push('enrollment challenge ciphertext must contain exactly 32 bytes');
+    }
+    if (errors.length === 0) {
+      const context = createSecretRecipientEnrollmentChallengeContext({
+        enrollmentId: challenge.enrollmentId as string,
+        clusterId: challenge.clusterId as string,
+        recipientKeyId: challenge.recipientKeyId as string,
+        publicKey: challenge.publicKey as string,
+        generation: challenge.generation as number,
+        expiresAt: challenge.expiresAt as number,
+      });
+      if (!await verifySecretEnvelopeContext(envelope, context)) {
+        errors.push('enrollment challenge context does not match');
+      }
+    }
+  }
+  return errors;
+};
+
+export const validateCompleteSecretRecipientEnrollmentRequest = (
+  requestArg: unknown,
+): string[] => {
+  if (!requestArg || typeof requestArg !== 'object' || Array.isArray(requestArg)) {
+    return ['enrollment completion must be an object'];
+  }
+  const request = requestArg as Record<string, unknown>;
+  const errors: string[] = [];
+  if (JSON.stringify(Object.keys(request).sort()) !== JSON.stringify([
+    'enrollmentId',
+    'expectedGeneration',
+    'identity',
+    'response',
+  ])) {
+    errors.push('enrollment completion must use its exact schema');
+  }
+  if (!request.identity || typeof request.identity !== 'object'
+    || typeof (request.identity as Record<string, unknown>).jwt !== 'string') {
+    errors.push('enrollment identity must be a JWT credential');
+  }
+  if (typeof request.enrollmentId !== 'string'
+    || !canonicalIdentifierRegex.test(request.enrollmentId)) {
+    errors.push('enrollment id must be canonical');
+  }
+  if (!Number.isSafeInteger(request.expectedGeneration)
+    || (request.expectedGeneration as number) < 0) {
+    errors.push('expected generation must be a non-negative integer');
+  }
+  if (typeof request.response !== 'string' || !raw32ByteBase64UrlRegex.test(request.response)) {
+    errors.push('enrollment response must be canonical base64url containing exactly 32 bytes');
+  }
+  if ('clusterId' in request || 'organizationId' in request) {
+    errors.push('enrollment completion must not select cluster or organization scope');
+  }
+  return errors;
+};
+
+export { validateSecretRecipientMetadata };

package/dist_ts/data/secretbundle.d.ts

@@ -1,57 +0,0 @@
-/**
- * @deprecated Compatibility-only persisted shape. Service-owned Secrets and
- * explicit same-organization SecretSets replace this model.
- */
-export interface ISecretBundle {
-    id: string;
-    data: {
-        name: string;
-        description: string;
-        /**
-         * determines if the secret is a service or an external secret
-         * if external secret additional checks are put in place to protect the secret
-         *
-         * * service:
-         *   the bundle belongs to a service and can only be used by that service
-         * * npmci:
-         *   the bundle is a secret bundle that is used by an npmci pipeline
-         *   production secrets will be omitted in any case
-         * * gitzone:
-         *   the bundle is a secret bundle that is used by a gitzone.
-         *   Only local environment variables are allowed
-         * * external:
-         *   the bundle is a secret bundle that is used by an external service
-         */
-        type: 'service' | 'npmci' | 'gitzone' | 'external';
-        /**
-         * set this if the secretBundle belongs to a service
-         */
-        serviceId?: string;
-        /**
-         * You can add specific secret groups using this
-         */
-        includedSecretGroupIds: string[];
-        /**
-         * access to this secretBundle also grants access to resources with matching tags
-         */
-        includedTags: {
-            key: string;
-            value?: string;
-        }[];
-        /**
-         * access to this secretBundle also grants access to the images
-         */
-        imageClaims: {
-            imageId: string;
-            permissions: ('read' | 'write')[];
-        }[];
-        /**
-         * authrozations select a specific environment of a config bundle
-         */
-        authorizations: Array<ISecretBundleAuthorization>;
-    };
-}
-export interface ISecretBundleAuthorization {
-    secretAccessKey: string;
-    environment: string;
-}

package/dist_ts/data/secretbundle.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0YnVuZGxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvZGF0YS9zZWNyZXRidW5kbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/data/secretgroup.d.ts

@@ -1,52 +0,0 @@
-/**
- * @deprecated Compatibility-only persisted shape. Migrate to ISecretMetadata
- * and immutable SecretVersion records; do not create new SecretGroups.
- */
-export interface ISecretGroup {
-    /**
-     * the insatnce id. This should be a random id, except for default
-     */
-    id: string;
-    data: {
-        name: string;
-        description: string;
-        /**
-         * the key of the secretgroup like CI_RUNNER_TOKEN
-         */
-        key: string;
-        /**
-         * the priority of the secretgroup
-         * will be used to determine which secretgroup will be used
-         * when there are multiple secretgroups with the same key
-         */
-        priority?: number;
-        /**
-         * any tags that can be used to filter the secretgroup
-         * can be used for putting secrets into projects
-         */
-        tags: {
-            key: string;
-            value: string;
-        }[];
-        /**
-         * the values for this secretGroup
-         */
-        environments: {
-            [key: string]: {
-                value: string;
-                /**
-                 * can be used to update the value
-                 */
-                updateToken?: string;
-                /**
-                 * the linux timestamp of the last update
-                 */
-                lastUpdated: number;
-                history: {
-                    timestamp: string;
-                    value: string;
-                }[];
-            };
-        };
-    };
-}

package/dist_ts/data/secretgroup.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0Z3JvdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL3NlY3JldGdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/requests/secretbundle.d.ts

@@ -1,75 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as data from '../data/index.js';
-import * as userInterfaces from '../data/user.js';
-export interface IReq_GetSecretBundles extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetSecretBundles> {
-    method: 'getSecretBundles';
-    request: {
-        identity: userInterfaces.IIdentity;
-    };
-    response: {
-        secretBundles: data.ISecretBundle[];
-    };
-}
-export interface IReq_GetSecretBundleById extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetSecretBundleById> {
-    method: 'getSecretBundleById';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretBundleId: string;
-    };
-    response: {
-        secretBundle: data.ISecretBundle;
-    };
-}
-export interface IReq_CreateSecretBundle extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_CreateSecretBundle> {
-    method: 'createSecretBundle';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretBundle: data.ISecretBundle;
-    };
-    response: {
-        resultSecretBundle: data.ISecretBundle;
-    };
-}
-export interface IReq_UpdateSecretBundle extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_UpdateSecretBundle> {
-    method: 'updateSecretBundle';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretBundle: data.ISecretBundle;
-    };
-    response: {
-        resultSecretBundle: data.ISecretBundle;
-    };
-}
-export interface IReq_DeleteSecretBundleById extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_DeleteSecretBundleById> {
-    method: 'deleteSecretBundleById';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretBundleId: string;
-    };
-    response: {
-        ok: boolean;
-    };
-}
-export interface IReq_GetSecretBundleByAuthorization extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetSecretBundleByAuthorization> {
-    method: 'getSecretBundleByAuthorization';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretBundleAuthorization: data.ISecretBundleAuthorization;
-    };
-    response: {
-        secretBundle: data.ISecretBundle;
-    };
-}
-export interface IReq_GetFlatKeyValueObject extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetFlatKeyValueObject> {
-    method: 'getFlatKeyValueObject';
-    request: {
-        identity: userInterfaces.IIdentity;
-        seccretBundleId: string;
-        secretBundleAuthorization: data.ISecretBundleAuthorization;
-    };
-    response: {
-        flatKeyValueObject: {
-            [key: string]: string;
-        };
-    };
-}

package/dist_ts/requests/secretbundle.js

@@ -1,4 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as data from '../data/index.js';
-import * as userInterfaces from '../data/user.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0YnVuZGxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvcmVxdWVzdHMvc2VjcmV0YnVuZGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sa0JBQWtCLENBQUM7QUFDekMsT0FBTyxLQUFLLGNBQWMsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dist_ts/requests/secretgroup.d.ts

@@ -1,52 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as data from '../data/index.js';
-import * as userInterfaces from '../data/user.js';
-export interface IReq_GetSecretGroups extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetSecretGroups> {
-    method: 'getSecretGroups';
-    request: {
-        identity: userInterfaces.IIdentity;
-    };
-    response: {
-        secretGroups: data.ISecretGroup[];
-    };
-}
-export interface IReq_GetSecretGroupById extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetSecretGroupById> {
-    method: 'getSecretGroupById';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretGroupId: string;
-    };
-    response: {
-        secretGroup: data.ISecretGroup;
-    };
-}
-export interface IReq_CreateSecretGroup extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_CreateSecretGroup> {
-    method: 'createSecretGroup';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretGroup: data.ISecretGroup;
-    };
-    response: {
-        resultSecretGroup: data.ISecretGroup;
-    };
-}
-export interface IReq_UpdateSecretGroup extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_UpdateSecretGroup> {
-    method: 'updateSecretGroup';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretGroup: data.ISecretGroup;
-    };
-    response: {
-        resultSecretGroup: data.ISecretGroup;
-    };
-}
-export interface IReq_DeleteSecretGroupById extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_DeleteSecretGroupById> {
-    method: 'deleteSecretGroupById';
-    request: {
-        identity: userInterfaces.IIdentity;
-        secretGroupId: string;
-    };
-    response: {
-        ok: boolean;
-    };
-}

package/dist_ts/requests/secretgroup.js

@@ -1,4 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as data from '../data/index.js';
-import * as userInterfaces from '../data/user.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0Z3JvdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9yZXF1ZXN0cy9zZWNyZXRncm91cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxjQUFjLE1BQU0saUJBQWlCLENBQUMifQ==