@turnkey/http 0.1.3 → 0.3.0

package/dist/__generated__/{coordinator/tkhq → services/coordinator}/public/v1/public_api.types.d.ts

@@ -11,13 +11,25 @@ export type paths = {
         /** Get details about an Organization */
         post: operations["PublicApiService_GetOrganization"];
     };
+    "/public/v1/query/get_policy": {
+        /** Get details about a Policy */
+        post: operations["PublicApiService_GetPolicy"];
+    };
     "/public/v1/query/get_user": {
         /** Get details about a User */
         post: operations["PublicApiService_GetUser"];
     };
-    "/public/v1/query/list_keys": {
+    "/public/v1/query/list_activities": {
+        /** List all Activities within an Organization */
+        post: operations["PublicApiService_GetActivities"];
+    };
+    "/public/v1/query/list_policies": {
+        /** List all Policies within an Organization */
+        post: operations["PublicApiService_GetPolicies"];
+    };
+    "/public/v1/query/list_private_keys": {
         /** List all Private Keys within an Organization */
-        post: operations["PublicApiService_GetKeys"];
+        post: operations["PublicApiService_GetPrivateKeys"];
     };
     "/public/v1/query/list_users": {
         /** List all Users within an Organization */
@@ -35,17 +47,13 @@ export type paths = {
         /** Create Invitations to join an existing Organization */
         post: operations["PublicApiService_CreateInvitations"];
     };
-    "/public/v1/submit/create_keys": {
-        /** Create new Private Keys */
-        post: operations["PublicApiService_CreateKeys"];
-    };
     "/public/v1/submit/create_policy": {
         /** Create a new Policy */
         post: operations["PublicApiService_CreatePolicy"];
     };
-    "/public/v1/submit/create_users": {
-        /** Create new API Users */
-        post: operations["PublicApiService_CreateUsers"];
+    "/public/v1/submit/create_private_keys": {
+        /** Create new Private Keys */
+        post: operations["PublicApiService_CreatePrivateKeys"];
     };
     "/public/v1/submit/delete_api_keys": {
         /** Remove api keys from a User */
@@ -59,686 +67,448 @@ export type paths = {
         /** Delete an existing Policy */
         post: operations["PublicApiService_DeletePolicy"];
     };
-    "/public/v1/submit/delete_users": {
-        /** Deactivate an existing User */
-        post: operations["PublicApiService_DeleteUsers"];
-    };
-    "/public/v1/submit/sign": {
-        /** Sign a message with a Private Key */
-        post: operations["PublicApiService_SignMessage"];
+    "/public/v1/submit/sign_raw_payload": {
+        /** Sign a raw payload with a Private Key */
+        post: operations["PublicApiService_SignRawPayload"];
     };
     "/public/v1/submit/sign_transaction": {
         /** Sign a transaction with a Private Key */
         post: operations["PublicApiService_SignTransaction"];
     };
-    "/tkhq/public/v1/query/get_key": {
+    "/tkhq/public/v1/query/get_private_key": {
         /** Get details about a Private Key */
-        post: operations["PublicApiService_GetKey"];
+        post: operations["PublicApiService_GetPrivateKey"];
     };
 };
 export type definitions = {
-    activityActivity: {
-        id: string;
-        organizationId: string;
-        status: definitions["activityActivityStatus"];
-        type: definitions["activityActivityType"];
-        intent: definitions["enforcementIntent"];
-        result: definitions["enforcementResult"];
-        votes: definitions["activityVote"][];
-        fingerprint: string;
-        canApprove: boolean;
-        canReject: boolean;
+    datav1Tag: {
+        tagId: string;
+        label: string;
+        tagType: definitions["v1TagType"];
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
     };
     /** @enum {string} */
-    activityActivityStatus: "ACTIVITY_STATUS_CREATED" | "ACTIVITY_STATUS_PENDING" | "ACTIVITY_STATUS_COMPLETED" | "ACTIVITY_STATUS_FAILED" | "ACTIVITY_STATUS_CONSENSUS_NEEDED" | "ACTIVITY_STATUS_REJECTED";
+    externaldatav1AccessType: "ACCESS_TYPE_WEB" | "ACCESS_TYPE_API" | "ACCESS_TYPE_ALL";
+    externaldatav1Address: {
+        format?: definitions["externaldatav1AddressFormat"];
+        address?: string;
+    };
     /**
-     * These are all of the types of user-facing activities on Turnkey
-     * We use this to guide the polymorphic parsing of activity requests/approvals/rejections
-     * One activity type maps to one internal Intent, but not all internal intents have a user-facing activity (e.g. Hearbeats)
+     * - ADDRESS_FORMAT_UNCOMPRESSED: 04<X_COORDINATE><Y_COORDINATE>
+     *  - ADDRESS_FORMAT_COMPRESSED: 02 or 03, followed by the X coordinate
+     *  - ADDRESS_FORMAT_ETHEREUM: Your standard Ethereum address (0x...). We apply EIP55 casing.
+     *  - ADDRESS_FORMAT_BITCOIN_P2PKH: Bitoin formats. See https://en.bitcoin.it/wiki/List_of_address_prefixes
      * @enum {string}
      */
-    activityActivityType: "ACTIVITY_TYPE_ADD_API_KEYS" | "ACTIVITY_TYPE_ADD_USERS" | "ACTIVITY_TYPE_ADD_KEYS" | "ACTIVITY_TYPE_SIGN_MESSAGE" | "ACTIVITY_TYPE_CREATE_INVITATIONS" | "ACTIVITY_TYPE_ACCEPT_INVITATION" | "ACTIVITY_TYPE_ADD_POLICY" | "ACTIVITY_TYPE_REMOVE_KEY" | "ACTIVITY_TYPE_REMOVE_USERS" | "ACTIVITY_TYPE_REMOVE_API_KEYS" | "ACTIVITY_TYPE_REMOVE_INVITATION" | "ACTIVITY_TYPE_REMOVE_ORGANIZATION" | "ACTIVITY_TYPE_REMOVE_POLICY" | "ACTIVITY_TYPE_ADD_TAG" | "ACTIVITY_TYPE_REMOVE_TAGS" | "ACTIVITY_TYPE_CREATE_ORGANIZATION" | "ACTIVITY_TYPE_SIGN_TRANSACTION" | "ACTIVITY_TYPE_APPROVE_ACTIVITY" | "ACTIVITY_TYPE_REJECT_ACTIVITY" | "ACTIVITY_TYPE_REMOVE_AUTHENTICATORS" | "ACTIVITY_TYPE_ADD_AUTHENTICATORS";
-    activityCreateApiKeysRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_ADD_API_KEYS";
-        requestId?: string;
-        organizationId: string;
-        intent: definitions["enforcementAddApiKeysIntent"];
-    };
-    activityCreateInvitationsRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_CREATE_INVITATIONS";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementCreateInvitationsIntent"];
+    externaldatav1AddressFormat: "ADDRESS_FORMAT_UNCOMPRESSED" | "ADDRESS_FORMAT_COMPRESSED" | "ADDRESS_FORMAT_ETHEREUM" | "ADDRESS_FORMAT_BITCOIN_P2PKH" | "ADDRESS_FORMAT_BITCOIN_P2PKH_TESTNET";
+    /** @enum {string} */
+    externaldatav1AuthenticatorTransport: "AUTHENTICATOR_TRANSPORT_BLE" | "AUTHENTICATOR_TRANSPORT_INTERNAL" | "AUTHENTICATOR_TRANSPORT_NFC" | "AUTHENTICATOR_TRANSPORT_USB" | "AUTHENTICATOR_TRANSPORT_HYBRID";
+    /**
+     * - CURVE_SECP256K1: The only curve we're planning to support short-term
+     * @enum {string}
+     */
+    externaldatav1Curve: "CURVE_SECP256K1";
+    /** @enum {string} */
+    externaldatav1Effect: "EFFECT_ALLOW" | "EFFECT_DENY";
+    /** @enum {string} */
+    externaldatav1Operator: "OPERATOR_EQUAL" | "OPERATOR_MORE_THAN" | "OPERATOR_MORE_THAN_OR_EQUAL" | "OPERATOR_LESS_THAN" | "OPERATOR_LESS_THAN_OR_EQUAL" | "OPERATOR_CONTAINS" | "OPERATOR_NOT_EQUAL";
+    externaldatav1Selector: {
+        subject: string;
+        operator: definitions["externaldatav1Operator"];
+        target: string;
     };
-    activityCreateKeysRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_ADD_KEYS";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementAddKeysIntent"];
+    /** @enum {string} */
+    immutableactivityv1AccessType: "ACCESS_TYPE_WEB" | "ACCESS_TYPE_API" | "ACCESS_TYPE_ALL";
+    /**
+     * - ADDRESS_FORMAT_UNCOMPRESSED: 04<X_COORDINATE><Y_COORDINATE>
+     *  - ADDRESS_FORMAT_COMPRESSED: 02 or 03, followed by the X coordinate
+     *  - ADDRESS_FORMAT_ETHEREUM: Your standard Ethereum address (0x...). We apply EIP55 casing.
+     *  - ADDRESS_FORMAT_BITCOIN_P2PKH: Bitoin formats. See https://en.bitcoin.it/wiki/List_of_address_prefixes
+     * @enum {string}
+     */
+    immutableactivityv1AddressFormat: "ADDRESS_FORMAT_UNCOMPRESSED" | "ADDRESS_FORMAT_COMPRESSED" | "ADDRESS_FORMAT_ETHEREUM" | "ADDRESS_FORMAT_BITCOIN_P2PKH" | "ADDRESS_FORMAT_BITCOIN_P2PKH_TESTNET";
+    /**
+     * - CURVE_SECP256K1: The only curve we're planning to support short-term
+     * @enum {string}
+     */
+    immutableactivityv1Curve: "CURVE_SECP256K1";
+    /** @enum {string} */
+    immutableactivityv1Effect: "EFFECT_ALLOW" | "EFFECT_DENY";
+    /** @enum {string} */
+    immutableactivityv1Operator: "OPERATOR_EQUAL" | "OPERATOR_MORE_THAN" | "OPERATOR_MORE_THAN_OR_EQUAL" | "OPERATOR_LESS_THAN" | "OPERATOR_LESS_THAN_OR_EQUAL" | "OPERATOR_CONTAINS" | "OPERATOR_NOT_EQUAL";
+    immutableactivityv1Selector: {
+        subject?: string;
+        operator?: definitions["immutableactivityv1Operator"];
+        target?: string;
     };
-    /** TODO(tim) - add timestamp to all these requests to prevent replay attack in the event the DB has been tampered with */
-    activityCreatePolicyRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_ADD_POLICY";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementAddPolicyIntent"];
+    /**
+     * - TRANSACTION_TYPE_ETHEREUM: Unsigned Ethereum transaction, RLP-encoded and hex-encoded
+     * @enum {string}
+     */
+    immutableactivityv1TransactionType: "TRANSACTION_TYPE_ETHEREUM";
+    /** @enum {string} */
+    immutablewebauthnv1AuthenticatorTransport: "AUTHENTICATOR_TRANSPORT_BLE" | "AUTHENTICATOR_TRANSPORT_INTERNAL" | "AUTHENTICATOR_TRANSPORT_NFC" | "AUTHENTICATOR_TRANSPORT_USB" | "AUTHENTICATOR_TRANSPORT_HYBRID";
+    protobufAny: {
+        "@type"?: string;
+    } & {
+        [key: string]: unknown;
     };
-    activityCreateUsersRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_ADD_USERS";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementAddUsersIntent"];
+    rpcStatus: {
+        /** Format: int32 */
+        code?: number;
+        message?: string;
+        details?: definitions["protobufAny"][];
     };
-    activityDeleteApiKeysRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_REMOVE_API_KEYS";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementRemoveApiKeysIntent"];
+    v1AcceptInvitationIntent: {
+        /** @inject_tag: validate:"required,uuid" */
+        invitationId: string;
+        /** @inject_tag: validate:"required,uuid" */
+        userId: string;
+        authenticator: definitions["v1AuthenticatorParams"];
     };
-    activityDeleteInvitationRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_REMOVE_INVITATION";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementRemoveInvitationIntent"];
+    v1AcceptInvitationResult: {
+        invitationId: string;
+        userId: string;
     };
-    activityDeletePolicyRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_REMOVE_POLICY";
-        requestId: string;
+    v1Activity: {
+        id: string;
         organizationId: string;
-        intent: definitions["enforcementRemovePolicyIntent"];
+        status: definitions["v1ActivityStatus"];
+        type: definitions["v1ActivityType"];
+        intent: definitions["v1Intent"];
+        result: definitions["v1Result"];
+        votes: definitions["v1Vote"][];
+        fingerprint: string;
+        canApprove: boolean;
+        canReject: boolean;
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
     };
-    activityDeleteUsersRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_REMOVE_USERS";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementRemoveUsersIntent"];
+    v1ActivityResponse: {
+        activity: definitions["v1Activity"];
     };
-    activitySignMessageRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_SIGN_MESSAGE";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementSignMessageIntent"];
+    /** @enum {string} */
+    v1ActivityStatus: "ACTIVITY_STATUS_CREATED" | "ACTIVITY_STATUS_PENDING" | "ACTIVITY_STATUS_COMPLETED" | "ACTIVITY_STATUS_FAILED" | "ACTIVITY_STATUS_CONSENSUS_NEEDED" | "ACTIVITY_STATUS_REJECTED";
+    /**
+     * These are all of the types of user-facing activities on Turnkey
+     * We use this to guide the polymorphic parsing of activity requests/approvals/rejections
+     * One activity type maps to one internal Intent, but not all internal intents have a user-facing activity (e.g. Hearbeats)
+     * @enum {string}
+     */
+    v1ActivityType: "ACTIVITY_TYPE_CREATE_API_KEYS" | "ACTIVITY_TYPE_CREATE_USERS" | "ACTIVITY_TYPE_CREATE_PRIVATE_KEYS" | "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD" | "ACTIVITY_TYPE_CREATE_INVITATIONS" | "ACTIVITY_TYPE_ACCEPT_INVITATION" | "ACTIVITY_TYPE_CREATE_POLICY" | "ACTIVITY_TYPE_DISABLE_PRIVATE_KEY" | "ACTIVITY_TYPE_DELETE_USERS" | "ACTIVITY_TYPE_DELETE_API_KEYS" | "ACTIVITY_TYPE_DELETE_INVITATION" | "ACTIVITY_TYPE_DELETE_ORGANIZATION" | "ACTIVITY_TYPE_DELETE_POLICY" | "ACTIVITY_TYPE_CREATE_USER_TAG" | "ACTIVITY_TYPE_DELETE_USER_TAGS" | "ACTIVITY_TYPE_CREATE_ORGANIZATION" | "ACTIVITY_TYPE_SIGN_TRANSACTION" | "ACTIVITY_TYPE_APPROVE_ACTIVITY" | "ACTIVITY_TYPE_REJECT_ACTIVITY" | "ACTIVITY_TYPE_DELETE_AUTHENTICATORS" | "ACTIVITY_TYPE_CREATE_AUTHENTICATORS" | "ACTIVITY_TYPE_CREATE_PRIVATE_KEY_TAG" | "ACTIVITY_TYPE_DELETE_PRIVATE_KEY_TAGS";
+    v1ApiKey: {
+        credential: definitions["v1Credential"];
+        apiKeyId: string;
+        apiKeyName: string;
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
+    };
+    v1ApiKeyParams: {
+        /** @inject_tag: validate:"required,max=40" */
+        apiKeyName: string;
+        /** @inject_tag: validate:"hexadecimal,len=66" */
+        publicKey: string;
     };
-    activitySignTransactionRequest: {
-        /** @enum {string} */
-        type: "ACTIVITY_TYPE_SIGN_TRANSACTION";
-        requestId: string;
-        organizationId: string;
-        intent: definitions["enforcementSignTransactionIntent"];
+    v1ApproveActivityIntent: {
+        /** @inject_tag: validate:"required" */
+        fingerprint: string;
     };
-    activityVote: {
-        id: string;
+    v1Authenticator: {
+        transports: definitions["externaldatav1AuthenticatorTransport"][];
+        attestationType: string;
+        aaguid: string;
         userId: string;
-        user: definitions["resourcesUser"];
-        activityId: string;
+        credentialId: string;
+        model: string;
+        credential: definitions["v1Credential"];
+        authenticatorId: string;
+        label: string;
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
+    };
+    v1AuthenticatorAttestationResponse: {
+        /** ENCODING: base64url */
+        clientDataJson: string;
+        /** ENCODING: base64url */
+        attestationObject: string;
+        transports?: definitions["immutablewebauthnv1AuthenticatorTransport"][];
         /** @enum {string} */
-        selection: "VOTE_SELECTION_APPROVED" | "VOTE_SELECTION_REJECTED";
-        message: string;
-        publicKey: string;
-        signature: string;
-        scheme: string;
-        createdAt: definitions["resourcesTimestamp"];
+        authenticatorAttachment?: "cross-platform" | "platform" | null;
     };
-    /**
-     * - CURVE_SECP256K1: The only curve we're planning to support short-term
-     *  - CURVE_ED25519: Demonstrates an error case, we aren't going to support this curve at first
-     * @enum {string}
-     */
-    curveCurve: "CURVE_SECP256K1" | "CURVE_ED25519";
-    enforcementAcceptInvitationIntent: {
-        /** @inject_tag: validate:"required,uuid" */
-        invitationId: string;
+    v1AuthenticatorParams: {
+        /** @inject_tag: validate:"required,max=40" */
+        authenticatorName: string;
         /** @inject_tag: validate:"required,uuid" */
         userId: string;
-        authenticator: definitions["enforcementAuthenticatorParams"];
-    };
-    enforcementAcceptInvitationResult: {
-        invitationId: string;
-        newUserId: string;
+        attestation: definitions["v1PublicKeyCredentialWithAttestation"];
+        /** @inject_tag: validate:"required,max=256" */
+        challenge: string;
     };
-    enforcementAddApiKeysIntent: {
+    v1CreateApiKeysIntent: {
         /** @inject_tag: validate:"dive,required" */
-        apiKeys: definitions["enforcementApiKeyParams"][];
+        apiKeys: definitions["v1ApiKeyParams"][];
         /** @inject_tag: validate:"required,uuid" */
         userId: string;
     };
-    enforcementAddApiKeysResult: {
+    v1CreateApiKeysRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_CREATE_API_KEYS";
+        timestamp?: string;
+        organizationId: string;
+        parameters: definitions["v1CreateApiKeysIntent"];
+    };
+    v1CreateApiKeysResult: {
         apiKeyIds: string[];
     };
-    enforcementAddAuthenticatorsIntent: {
+    v1CreateAuthenticatorsIntent: {
         /** @inject_tag: validate:"dive,required" */
-        authenticators: definitions["enforcementAuthenticatorParams"][];
+        authenticators: definitions["v1AuthenticatorParams"][];
         /** @inject_tag: validate:"required,uuid" */
         userId: string;
     };
-    enforcementAddAuthenticatorsResult: {
+    v1CreateAuthenticatorsResult: {
         authenticatorIds: string[];
     };
-    enforcementAddKeysIntent: {
-        /** @inject_tag: validate:"dive,required" */
-        keys: definitions["enforcementKeyParams"][];
-    };
-    enforcementAddKeysResult: {
-        keys: definitions["resourcesExternalKey"][];
-    };
-    enforcementAddPolicyIntent: {
-        /** @inject_tag: validate:"required,max=40" */
-        label: string;
+    v1CreateInvitationsIntent: {
         /** @inject_tag: validate:"required,dive,required" */
-        selectors: definitions["resourcesSelector"][];
-        effect: definitions["policyEffect"];
-        /** @inject_tag: validate:"required,max=256" */
-        notes: string;
+        invitations: definitions["v1InvitationParams"][];
     };
-    enforcementAddPolicyResult: {
-        newPolicyId: string;
+    v1CreateInvitationsRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_CREATE_INVITATIONS";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1CreateInvitationsIntent"];
     };
-    enforcementAddTagIntent: {
-        /** @inject_tag: validate:"required,max=20" */
-        label: string;
-        tagType: definitions["resourcesTagType"];
-        /** @inject_tag: validate:"dive,uuid" */
-        resourceIds: string[];
+    v1CreateInvitationsResult: {
+        invitationIds: string[];
     };
-    enforcementAddTagResult: {
-        tagId: string;
-        tagType: definitions["resourcesTagType"];
-        resourceIds: string[];
+    v1CreateOrganizationIntent: {
+        /** @inject_tag: validate:"required,max=40" */
+        organizationName: string;
+        /** @inject_tag: validate:"required,email" */
+        rootEmail: string;
+        rootAuthenticator: definitions["v1AuthenticatorParams"];
+        /** @inject_tag: validate:"uuid" */
+        rootUserId?: string;
+    };
+    v1CreateOrganizationResult: {
+        organizationId: string;
     };
-    enforcementAddUsersIntent: {
+    v1CreatePolicyIntent: {
+        /** @inject_tag: validate:"required,max=40" */
+        policyName: string;
         /** @inject_tag: validate:"required,dive,required" */
-        users: definitions["enforcementUserParams"][];
+        selectors: definitions["immutableactivityv1Selector"][];
+        effect: definitions["immutableactivityv1Effect"];
+        notes?: string;
     };
-    enforcementAddUsersResult: {
-        userIds: string[];
+    v1CreatePolicyRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_CREATE_POLICY";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1CreatePolicyIntent"];
     };
-    enforcementApiKeyParams: {
-        /** @inject_tag: validate:"required,max=40" */
-        label: string;
-        /** @inject_tag: validate:"hexadecimal,len=66" */
-        publicKey: string;
-        /** @inject_tag: "required,dive,uuid" */
-        tags: string[];
+    v1CreatePolicyResult: {
+        policyId: string;
     };
-    enforcementApproveActivityIntent: {
-        /** @inject_tag: validate:"required" */
-        fingerprint: string;
+    v1CreatePrivateKeyTagIntent: {
+        /** @inject_tag: validate:"required,max=20" */
+        privateKeyTagName: string;
+        /** @inject_tag: validate:"dive,uuid" */
+        privateKeyIds: string[];
     };
-    enforcementAuthenticatorParams: {
-        /** @inject_tag: validate:"required,max=40" */
-        label: string;
-        /** @inject_tag: validate:"required,uuid" */
-        userId: string;
-        attestation: definitions["webauthnPublicKeyCredentialWithAttestation"];
-        /** @inject_tag: validate:"required,max=256" */
-        challenge: string;
-        /** @inject_tag: "required,dive,uuid" */
-        tags: string[];
+    v1CreatePrivateKeyTagResult: {
+        privateKeyTagId: string;
+        privateKeyIds: string[];
     };
-    enforcementCreateInvitationsIntent: {
-        /** @inject_tag: validate:"required,dive,required" */
-        invitations: definitions["enforcementInvitationParams"][];
+    v1CreatePrivateKeysIntent: {
+        /** @inject_tag: validate:"dive,required" */
+        privateKeys: definitions["v1PrivateKeyParams"][];
     };
-    enforcementCreateInvitationsResult: {
-        invitationIds: string[];
+    v1CreatePrivateKeysRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_CREATE_PRIVATE_KEYS";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1CreatePrivateKeysIntent"];
     };
-    enforcementCreateOrganizationIntent: {
-        /** @inject_tag: validate:"required,max=40" */
-        name: string;
-        /** @inject_tag: validate:"required,email" */
-        rootEmail: string;
-        rootAuthenticator: definitions["enforcementAuthenticatorParams"];
-        /** @inject_tag: validate:"uuid" */
-        rootUserUuid?: string;
+    v1CreatePrivateKeysResult: {
+        privateKeyIds: string[];
     };
-    enforcementCreateOrganizationResult: {
-        newOrgId: string;
+    v1CreateUserTagIntent: {
+        /** @inject_tag: validate:"required,max=20" */
+        userTagName: string;
+        /** @inject_tag: validate:"dive,uuid" */
+        userIds: string[];
     };
-    /** TODO(tim) - is this still needed? */
-    enforcementHeartbeatIntent: {
-        [key: string]: unknown;
+    v1CreateUserTagResult: {
+        userTagId: string;
+        userIds: string[];
     };
-    enforcementHeartbeatResult: {
-        [key: string]: unknown;
+    v1CreateUsersIntent: {
+        /** @inject_tag: validate:"required,dive,required" */
+        users: definitions["v1UserParams"][];
     };
-    enforcementIntent: {
-        createOrganizationIntent: definitions["enforcementCreateOrganizationIntent"];
-        heartbeatIntent?: definitions["enforcementHeartbeatIntent"];
-        addAuthenticatorsIntent?: definitions["enforcementAddAuthenticatorsIntent"];
-        addUsersIntent?: definitions["enforcementAddUsersIntent"];
-        addKeysIntent?: definitions["enforcementAddKeysIntent"];
-        signMessageIntent?: definitions["enforcementSignMessageIntent"];
-        createInvitationsIntent?: definitions["enforcementCreateInvitationsIntent"];
-        acceptInvitationIntent?: definitions["enforcementAcceptInvitationIntent"];
-        addPolicyIntent?: definitions["enforcementAddPolicyIntent"];
-        removeKeyIntent?: definitions["enforcementRemoveKeyIntent"];
-        removeUsersIntent?: definitions["enforcementRemoveUsersIntent"];
-        removeAuthenticatorsIntent?: definitions["enforcementRemoveAuthenticatorsIntent"];
-        removeInvitationIntent?: definitions["enforcementRemoveInvitationIntent"];
-        removeOrganizationIntent?: definitions["enforcementRemoveOrganizationIntent"];
-        removePolicyIntent?: definitions["enforcementRemovePolicyIntent"];
-        addTagIntent?: definitions["enforcementAddTagIntent"];
-        removeTagsIntent?: definitions["enforcementRemoveTagsIntent"];
-        signTransactionIntent?: definitions["enforcementSignTransactionIntent"];
-        addApiKeysIntent?: definitions["enforcementAddApiKeysIntent"];
-        removeApiKeysIntent?: definitions["enforcementRemoveApiKeysIntent"];
-        approveActivityIntent?: definitions["enforcementApproveActivityIntent"];
-        rejectActivityIntent?: definitions["enforcementRejectActivityIntent"];
-    };
-    enforcementInvitationParams: {
-        /** @inject_tag: validate:"required,max=40" */
-        receiverAlias: string;
-        /** @inject_tag: validate:"required,email" */
-        receiverEmail: string;
-        /** @inject_tag: validate:"dive,uuid" */
-        receiverTags: string[];
-        accessType: definitions["resourcesAccessType"];
-        /** @inject_tag: validate:"required,uuid" */
-        senderUserId: string;
+    v1CreateUsersResult: {
+        userIds: string[];
     };
-    enforcementKeyParams: {
-        /** @inject_tag: validate:"required,max=40" */
-        label: string;
-        curve: definitions["curveCurve"];
-        /** @inject_tag: validate:"dive,uuid" */
-        tags: string[];
-        /** @inject_tag: validate:"required" */
-        addressFormats: definitions["resourcesAddressFormat"][];
+    v1CredPropsAuthenticationExtensionsClientOutputs: {
+        rk: boolean;
     };
-    enforcementRejectActivityIntent: {
-        /** @inject_tag: validate:"required" */
-        fingerprint: string;
+    v1Credential: {
+        publicKey: string;
+        type: definitions["v1CredentialType"];
     };
-    enforcementRemoveApiKeysIntent: {
+    /** @enum {string} */
+    v1CredentialType: "CREDENTIAL_TYPE_WEBAUTHN_AUTHENTICATOR" | "CREDENTIAL_TYPE_API_KEY_P256";
+    v1DeleteApiKeysIntent: {
         /** @inject_tag: validate:"required,uuid" */
         userId: string;
         /** @inject_tag: validate:"required,dive,required,uuid" */
         apiKeyIds: string[];
     };
-    enforcementRemoveApiKeysResult: {
+    v1DeleteApiKeysRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_DELETE_API_KEYS";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1DeleteApiKeysIntent"];
+    };
+    v1DeleteApiKeysResult: {
         apiKeyIds: string[];
     };
-    enforcementRemoveAuthenticatorsIntent: {
+    v1DeleteAuthenticatorsIntent: {
         /** @inject_tag: validate:"required,uuid" */
         userId: string;
         /** @inject_tag: validate:"required,div,required,uuid" */
         authenticatorIds: string[];
     };
-    enforcementRemoveAuthenticatorsResult: {
+    v1DeleteAuthenticatorsResult: {
         authenticatorIds: string[];
     };
-    enforcementRemoveInvitationIntent: {
+    v1DeleteInvitationIntent: {
         /** @inject_tag: validate:"required,uuid" */
         invitationId: string;
     };
-    enforcementRemoveInvitationResult: {
-        invitationId: string;
-    };
-    enforcementRemoveKeyIntent: {
-        /** @inject_tag: validate:"required,uuid" */
-        keyId: string;
-    };
-    enforcementRemoveKeyResult: {
-        keyId: string;
-    };
-    enforcementRemoveOrganizationIntent: {
-        /** @inject_tag: validate:"required,uuid" */
-        organizationId: string;
-    };
-    enforcementRemoveOrganizationResult: {
+    v1DeleteInvitationRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_DELETE_INVITATION";
+        timestamp: string;
         organizationId: string;
+        parameters: definitions["v1DeleteInvitationIntent"];
     };
-    enforcementRemovePolicyIntent: {
-        /** @inject_tag: validate:"required,uuid" */
-        policyId: string;
-    };
-    enforcementRemovePolicyResult: {
-        policyId: string;
-    };
-    enforcementRemoveTagsIntent: {
-        /** @inject_tag: validate:"required,dive,required,uuid" */
-        tagIds: string[];
-        tagType: definitions["resourcesTagType"];
-    };
-    enforcementRemoveTagsResult: {
-        tagIds: string[];
-        tagType: definitions["resourcesTagType"];
-        resourceIds: string[];
-    };
-    enforcementRemoveUsersIntent: {
-        /** @inject_tag: validate:"required,dive,required,uuid" */
-        userIds: string[];
-    };
-    enforcementRemoveUsersResult: {
-        userIds: string[];
+    v1DeleteInvitationResult: {
+        invitationId: string;
     };
-    enforcementResult: {
-        createOrganizationResult?: definitions["enforcementCreateOrganizationResult"];
-        heartbeatResult?: definitions["enforcementHeartbeatResult"];
-        addAuthenticatorsResult?: definitions["enforcementAddAuthenticatorsResult"];
-        addUsersResult?: definitions["enforcementAddUsersResult"];
-        addKeysResult?: definitions["enforcementAddKeysResult"];
-        createInvitationsResult?: definitions["enforcementCreateInvitationsResult"];
-        acceptInvitationResult?: definitions["enforcementAcceptInvitationResult"];
-        signMessageResult?: definitions["enforcementSignMessageResult"];
-        addPolicyResult?: definitions["enforcementAddPolicyResult"];
-        removeKeyResult?: definitions["enforcementRemoveKeyResult"];
-        removeUsersResult?: definitions["enforcementRemoveUsersResult"];
-        removeAuthenticatorsResult?: definitions["enforcementRemoveAuthenticatorsResult"];
-        removeInvitationResult?: definitions["enforcementRemoveInvitationResult"];
-        removeOrganizationResult?: definitions["enforcementRemoveOrganizationResult"];
-        removePolicyResult?: definitions["enforcementRemovePolicyResult"];
-        addTagResult?: definitions["enforcementAddTagResult"];
-        removeTagsResult?: definitions["enforcementRemoveTagsResult"];
-        signTransactionResult?: definitions["enforcementSignTransactionResult"];
-        removeApiKeysResult?: definitions["enforcementRemoveApiKeysResult"];
-        addApiKeysResult?: definitions["enforcementAddApiKeysResult"];
-    };
-    enforcementSignMessageIntent: {
+    v1DeleteOrganizationIntent: {
         /** @inject_tag: validate:"required,uuid" */
         organizationId: string;
-        /** @inject_tag: validate:"required,uuid" */
-        keyId: string;
-        /** @inject_tag: validate:"required" */
-        payload: string;
-        encoding: definitions["signaturePayloadEncoding"];
-        hashFunction: definitions["signatureHashFunction"];
-    };
-    enforcementSignMessageResult: {
-        r: string;
-        s: string;
-        v: string;
     };
-    enforcementSignTransactionIntent: {
-        /** @inject_tag: validate:"required,uuid" */
+    v1DeleteOrganizationResult: {
         organizationId: string;
-        /** @inject_tag: validate:"required,uuid" */
-        keyId: string;
-        /** @inject_tag: validate:"required" */
-        unsignedTransaction: string;
-        type: definitions["resourcesTransactionType"];
-    };
-    enforcementSignTransactionResult: {
-        signedTransaction: string;
-    };
-    enforcementUserParams: {
-        /** @inject_tag: validate:"required,max=40" */
-        alias: string;
-        /** @inject_tag: validate:"email" */
-        email?: string;
-        accessType: definitions["resourcesAccessType"];
-        /** @inject_tag: validate:"dive,uuid" */
-        apiKeys: definitions["enforcementApiKeyParams"][];
-        /** @inject_tag: validate:"dive" */
-        authenticators: definitions["enforcementAuthenticatorParams"][];
-        /** @inject_tag: validate:"dive,uuid" */
-        tags: string[];
-    };
-    /**
-     * @description This proto definition dictates the encoding of organization data blobs in our database
-     * It does so indirectly: we use this message to derive Rust types. These Rust types are
-     * then used to serialize to, and deserialize from, JSON.
-     */
-    organization_dataOrganizationData: {
-        version?: string;
-        uuid?: string;
-        name?: string;
-        users?: definitions["resourcesUser"][];
-        policies?: definitions["resourcesPolicy"][];
-        keys?: definitions["resourcesKey"][];
-        invitations?: definitions["resourcesInvitation"][];
-        tags?: definitions["resourcesTag"][];
-        deletedUsers?: definitions["resourcesUser"][];
-        deletedPolicies?: definitions["resourcesPolicy"][];
-        deletedKeys?: definitions["resourcesKey"][];
-        deletedInvitations?: definitions["resourcesInvitation"][];
-        deletedApiKeys?: definitions["resourcesApiKey"][];
-        deletedAuthenticators?: definitions["resourcesAuthenticator"][];
-        deletedTags?: definitions["resourcesTag"][];
-    };
-    /** @enum {string} */
-    policyEffect: "EFFECT_ALLOW" | "EFFECT_DENY";
-    protobufAny: {
-        "@type"?: string;
-    } & {
-        [key: string]: unknown;
-    };
-    publicv1CreateApiKeysRequest: {
-        request: definitions["activityCreateApiKeysRequest"];
-    };
-    publicv1CreateInvitationsRequest: {
-        request: definitions["activityCreateInvitationsRequest"];
-    };
-    publicv1CreateKeysRequest: {
-        request: definitions["activityCreateKeysRequest"];
-    };
-    publicv1CreatePolicyRequest: {
-        request: definitions["activityCreatePolicyRequest"];
-    };
-    publicv1CreateUsersRequest: {
-        request: definitions["activityCreateUsersRequest"];
-    };
-    publicv1DeleteApiKeysRequest: {
-        request: definitions["activityDeleteApiKeysRequest"];
-    };
-    publicv1DeleteInvitationRequest: {
-        request: definitions["activityDeleteInvitationRequest"];
-    };
-    publicv1DeletePolicyRequest: {
-        request: definitions["activityDeletePolicyRequest"];
-    };
-    publicv1DeleteUsersRequest: {
-        request: definitions["activityDeleteUsersRequest"];
-    };
-    publicv1SignMessageRequest: {
-        request: definitions["activitySignMessageRequest"];
-    };
-    publicv1SignTransactionRequest: {
-        request: definitions["activitySignTransactionRequest"];
-    };
-    /** @enum {string} */
-    resourcesAccessType: "ACCESS_TYPE_WEB" | "ACCESS_TYPE_API" | "ACCESS_TYPE_ALL";
-    resourcesAddress: {
-        format?: definitions["resourcesAddressFormat"];
-        address?: string;
-    };
-    /**
-     * - ADDRESS_FORMAT_UNCOMPRESSED: 04<X_COORDINATE><Y_COORDINATE>
-     *  - ADDRESS_FORMAT_COMPRESSED: 02 or 03, followed by the X coordinate
-     *  - ADDRESS_FORMAT_ETHEREUM: Your standard Ethereum address (0x...). We apply EIP55 casing.
-     *  - ADDRESS_FORMAT_BITCOIN_P2PKH: Bitoin formats. See https://en.bitcoin.it/wiki/List_of_address_prefixes
-     * @enum {string}
-     */
-    resourcesAddressFormat: "ADDRESS_FORMAT_UNCOMPRESSED" | "ADDRESS_FORMAT_COMPRESSED" | "ADDRESS_FORMAT_ETHEREUM" | "ADDRESS_FORMAT_BITCOIN_P2PKH" | "ADDRESS_FORMAT_BITCOIN_P2PKH_TESTNET";
-    resourcesApiKey: {
-        credential: definitions["resourcesCredential"];
-        tags: string[];
-        uuid: string;
-        label: string;
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
     };
-    resourcesAuthenticator: {
-        transports: definitions["webauthnAuthenticatorTransport"][];
-        attestationType: string;
-        aaguid: string;
-        userId: string;
-        credentialId: string;
-        model: string;
-        credential: definitions["resourcesCredential"];
-        uuid: string;
-        label: string;
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
-        tags: string[];
+    v1DeletePolicyIntent: {
+        /** @inject_tag: validate:"required,uuid" */
+        policyId: string;
     };
-    resourcesCredential: {
-        publicKey: string;
-        scheme: definitions["signatureSignatureScheme"];
+    v1DeletePolicyRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_DELETE_POLICY";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1DeletePolicyIntent"];
     };
-    /** Key with data that is safe to share publicly */
-    resourcesExternalKey: {
-        uuid: string;
-        publicKey: string;
-        label: string;
-        curve: definitions["curveCurve"];
-        addresses: definitions["resourcesAddress"][];
-        tags: string[];
+    v1DeletePolicyResult: {
+        policyId: string;
     };
-    resourcesInvitation: {
-        uuid: string;
-        receiverAlias: string;
-        receiverEmail: string;
-        receiverTags: string[];
-        accessType: definitions["resourcesAccessType"];
-        status: definitions["resourcesInvitationStatus"];
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
-        senderUserId: string;
+    v1DeletePrivateKeyTagsIntent: {
+        /** @inject_tag: validate:"required,dive,required,uuid" */
+        privateKeyTagIds: string[];
     };
-    /** @enum {string} */
-    resourcesInvitationStatus: "INVITATION_STATUS_CREATED" | "INVITATION_STATUS_ACCEPTED" | "INVITATION_STATUS_REVOKED";
-    resourcesKey: {
-        uuid: string;
-        /** public key (!= address) */
-        publicKey: string;
-        /** encrypted private key */
-        encryptedPrivateKey: string;
-        label: string;
-        curve: definitions["curveCurve"];
-        addresses: definitions["resourcesAddress"][];
-        tags: string[];
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
+    v1DeletePrivateKeyTagsResult: {
+        privateKeyTagIds: string[];
+        privateKeyIds: string[];
     };
-    /** @enum {string} */
-    resourcesOperator: "OPERATOR_EQUAL" | "OPERATOR_MORE_THAN" | "OPERATOR_MORE_THAN_OR_EQUAL" | "OPERATOR_LESS_THAN" | "OPERATOR_LESS_THAN_OR_EQUAL" | "OPERATOR_CONTAINS" | "OPERATOR_NOT_EQUAL";
-    resourcesPolicy: {
-        uuid: string;
-        label: string;
-        effect: definitions["policyEffect"];
-        selectors: definitions["resourcesSelector"][];
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
-        notes: string;
+    v1DeleteUserTagsIntent: {
+        /** @inject_tag: validate:"required,dive,required,uuid" */
+        userTagIds: string[];
     };
-    resourcesSelector: {
-        subject: string;
-        operator: definitions["resourcesOperator"];
-        target: string;
+    v1DeleteUserTagsResult: {
+        userTagIds: string[];
+        userIds: string[];
     };
-    resourcesTag: {
-        uuid: string;
-        label: string;
-        tagType: definitions["resourcesTagType"];
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
+    v1DeleteUsersIntent: {
+        /** @inject_tag: validate:"required,dive,required,uuid" */
+        userIds: string[];
     };
-    /** @enum {string} */
-    resourcesTagType: "TAG_TYPE_USER" | "TAG_TYPE_API_KEY" | "TAG_TYPE_KEY" | "TAG_TYPE_AUTHENTICATOR";
-    /** Need borsch serialization, so can't use the internal timestamp */
-    resourcesTimestamp: {
-        seconds: string;
-        nanos: string;
+    v1DeleteUsersResult: {
+        userIds: string[];
     };
-    /**
-     * - TRANSACTION_TYPE_ETHEREUM: Unsigned Ethereum transaction, RLP-encoded and hex-encoded
-     * @enum {string}
-     */
-    resourcesTransactionType: "TRANSACTION_TYPE_ETHEREUM";
-    resourcesUser: {
-        uuid: string;
-        alias: string;
-        /** some users do not have emails (programmatic users) */
-        email?: string;
-        accessType: definitions["resourcesAccessType"];
-        authenticators: definitions["resourcesAuthenticator"][];
-        apiKeys: definitions["resourcesApiKey"][];
-        tags: string[];
-        createdAt: definitions["resourcesTimestamp"];
-        updatedAt: definitions["resourcesTimestamp"];
+    v1DisablePrivateKeyIntent: {
+        /** @inject_tag: validate:"required,uuid" */
+        privateKeyId: string;
     };
-    rpcStatus: {
-        /** Format: int32 */
-        code?: number;
-        message?: string;
-        details?: definitions["protobufAny"][];
+    v1DisablePrivateKeyResult: {
+        privateKeyId: string;
     };
-    /**
-     * @description  - HASH_FUNCTION_UNSPECIFIED: Default value if hash function is not set explicitly
-     *  - HASH_FUNCTION_NO_OP: No-op function. Useful if you want to pass raw bytes to sign
-     *  - HASH_FUNCTION_SHA256: Standard SHA-256
-     *  - HASH_FUNCTION_KECCAK256: Keccak-256 (not the same as NIST SHA-3!).
-     * This is the hash function used in the Ethereum ecosystem.
-     * @enum {string}
-     */
-    signatureHashFunction: "HASH_FUNCTION_NO_OP" | "HASH_FUNCTION_SHA256" | "HASH_FUNCTION_KECCAK256";
-    /**
-     * - PAYLOAD_ENCODING_UNSPECIFIED: Default value if payload encoding is not set explicitly
-     *  - PAYLOAD_ENCODING_HEXADECIMAL: Payload is encoded in hexadecimal
-     * We accept 0x-prefixed or non-0x prefixed payloads.
-     * We accept any casing (uppercase, lowercase, or mixed)
-     *  - PAYLOAD_ENCODING_TEXT_UTF8: Payload is encoded as utf-8 text
-     * Will be converted to bytes for signature with Rust's standard String.as_bytes()
-     * @enum {string}
-     */
-    signaturePayloadEncoding: "PAYLOAD_ENCODING_HEXADECIMAL" | "PAYLOAD_ENCODING_TEXT_UTF8";
-    /**
-     * - SIGNATURE_SCHEME_TK_API_P256: Scheme used for Turnkey's public API
-     *  - SIGNATURE_SCHEME_TK_WEBAUTHN: Scheme used on our UI when users sign with Webauthn
-     * Public keys are encoded using COSE (https://www.w3.org/TR/webauthn-2/#sctn-encoded-credPubKey-examples)
-     *  - SIGNATURE_SCHEME_TK_QUORUM_P256: Scheme used by our enclave applications
-     * @enum {string}
-     */
-    signatureSignatureScheme: "SIGNATURE_SCHEME_TK_API_P256" | "SIGNATURE_SCHEME_TK_WEBAUTHN" | "SIGNATURE_SCHEME_TK_QUORUM_P256";
-    v1ActivityResponse: {
-        activity: definitions["activityActivity"];
+    v1GetActivitiesRequest: {
+        organizationId: string;
+        filterByStatus?: definitions["v1ActivityStatus"][];
+    };
+    v1GetActivitiesResponse: {
+        activities: definitions["v1Activity"][];
     };
     v1GetActivityRequest: {
         organizationId: string;
         activityId: string;
     };
-    v1GetKeyRequest: {
+    v1GetOrganizationRequest: {
         organizationId: string;
-        keyId: string;
     };
-    v1GetKeyResponse: {
-        key: definitions["resourcesExternalKey"];
+    v1GetOrganizationResponse: {
+        organizationData: definitions["v1OrganizationData"];
     };
-    v1GetKeysRequest: {
+    v1GetPoliciesRequest: {
         organizationId: string;
     };
-    v1GetKeysResponse: {
-        keys: definitions["resourcesExternalKey"][];
+    v1GetPoliciesResponse: {
+        policies: definitions["v1Policy"][];
     };
-    v1GetOrganizationRequest: {
+    v1GetPolicyRequest: {
         organizationId: string;
+        policyId: string;
     };
-    v1GetOrganizationResponse: {
-        organizationData: definitions["organization_dataOrganizationData"];
+    v1GetPolicyResponse: {
+        policy: definitions["v1Policy"];
+    };
+    v1GetPrivateKeyRequest: {
+        organizationId: string;
+        privateKeyId: string;
+    };
+    v1GetPrivateKeyResponse: {
+        privateKey: definitions["v1PrivateKey"];
+    };
+    v1GetPrivateKeysRequest: {
+        organizationId: string;
+    };
+    v1GetPrivateKeysResponse: {
+        privateKeys: definitions["v1PrivateKey"][];
     };
     v1GetUserRequest: {
         organizationId: string;
         userId: string;
     };
     v1GetUserResponse: {
-        user: definitions["resourcesUser"];
+        user: definitions["v1User"];
     };
     v1GetUsersRequest: {
         organizationId: string;
     };
     v1GetUsersResponse: {
-        users: definitions["resourcesUser"][];
+        users: definitions["v1User"][];
     };
     v1GetWhoamiRequest: {
         organizationId: string;
@@ -749,21 +519,121 @@ export type definitions = {
         userId: string;
         username: string;
     };
-    webauthnAuthenticatorAttestationResponse: {
-        /** ENCODING: base64url */
-        clientDataJson: string;
-        /** ENCODING: base64url */
-        attestationObject: string;
-        transports?: definitions["webauthnAuthenticatorTransport"][];
-        /** @enum {string} */
-        authenticatorAttachment?: "cross-platform" | "platform" | null;
+    /**
+     * @description  - HASH_FUNCTION_UNSPECIFIED: Default value if hash function is not set explicitly
+     *  - HASH_FUNCTION_NO_OP: No-op function. Useful if you want to pass raw bytes to sign
+     *  - HASH_FUNCTION_SHA256: Standard SHA-256
+     *  - HASH_FUNCTION_KECCAK256: Keccak-256 (not the same as NIST SHA-3!).
+     * This is the hash function used in the Ethereum ecosystem.
+     * @enum {string}
+     */
+    v1HashFunction: "HASH_FUNCTION_NO_OP" | "HASH_FUNCTION_SHA256" | "HASH_FUNCTION_KECCAK256";
+    v1Intent: {
+        createOrganizationIntent: definitions["v1CreateOrganizationIntent"];
+        createAuthenticatorsIntent?: definitions["v1CreateAuthenticatorsIntent"];
+        createUsersIntent?: definitions["v1CreateUsersIntent"];
+        createPrivateKeysIntent?: definitions["v1CreatePrivateKeysIntent"];
+        signRawPayloadIntent?: definitions["v1SignRawPayloadIntent"];
+        createInvitationsIntent?: definitions["v1CreateInvitationsIntent"];
+        acceptInvitationIntent?: definitions["v1AcceptInvitationIntent"];
+        createPolicyIntent?: definitions["v1CreatePolicyIntent"];
+        disablePrivateKeyIntent?: definitions["v1DisablePrivateKeyIntent"];
+        deleteUsersIntent?: definitions["v1DeleteUsersIntent"];
+        deleteAuthenticatorsIntent?: definitions["v1DeleteAuthenticatorsIntent"];
+        deleteInvitationIntent?: definitions["v1DeleteInvitationIntent"];
+        deleteOrganizationIntent?: definitions["v1DeleteOrganizationIntent"];
+        deletePolicyIntent?: definitions["v1DeletePolicyIntent"];
+        createUserTagIntent?: definitions["v1CreateUserTagIntent"];
+        deleteUserTagsIntent?: definitions["v1DeleteUserTagsIntent"];
+        signTransactionIntent?: definitions["v1SignTransactionIntent"];
+        createApiKeysIntent?: definitions["v1CreateApiKeysIntent"];
+        deleteApiKeysIntent?: definitions["v1DeleteApiKeysIntent"];
+        approveActivityIntent?: definitions["v1ApproveActivityIntent"];
+        rejectActivityIntent?: definitions["v1RejectActivityIntent"];
+        createPrivateKeyTagIntent?: definitions["v1CreatePrivateKeyTagIntent"];
+        deletePrivateKeyTagsIntent?: definitions["v1DeletePrivateKeyTagsIntent"];
+    };
+    v1Invitation: {
+        invitationId: string;
+        receiverAlias: string;
+        receiverEmail: string;
+        receiverTags: string[];
+        accessType: definitions["externaldatav1AccessType"];
+        status: definitions["v1InvitationStatus"];
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
+        senderUserId: string;
+    };
+    v1InvitationParams: {
+        /** @inject_tag: validate:"required,max=40" */
+        receiverUserName: string;
+        /** @inject_tag: validate:"required,email" */
+        receiverUserEmail: string;
+        /** @inject_tag: validate:"dive,uuid" */
+        receiverUserTags: string[];
+        accessType: definitions["immutableactivityv1AccessType"];
+        /** @inject_tag: validate:"required,uuid" */
+        senderUserId: string;
     };
     /** @enum {string} */
-    webauthnAuthenticatorTransport: "AUTHENTICATOR_TRANSPORT_BLE" | "AUTHENTICATOR_TRANSPORT_INTERNAL" | "AUTHENTICATOR_TRANSPORT_NFC" | "AUTHENTICATOR_TRANSPORT_USB" | "AUTHENTICATOR_TRANSPORT_HYBRID";
-    webauthnCredPropsAuthenticationExtensionsClientOutputs: {
-        rk: boolean;
+    v1InvitationStatus: "INVITATION_STATUS_CREATED" | "INVITATION_STATUS_ACCEPTED" | "INVITATION_STATUS_REVOKED";
+    /**
+     * @description This proto definition is used in our external-facing APIs.
+     * It's important to leverage annotations because they're used in our external interfaces.
+     */
+    v1OrganizationData: {
+        organizationId?: string;
+        name?: string;
+        users?: definitions["v1User"][];
+        policies?: definitions["v1Policy"][];
+        privateKeys?: definitions["v1PrivateKey"][];
+        invitations?: definitions["v1Invitation"][];
+        tags?: definitions["datav1Tag"][];
+        deletedUsers?: definitions["v1User"][];
+        deletedPolicies?: definitions["v1Policy"][];
+        disabledPrivateKeys?: definitions["v1PrivateKey"][];
+        deletedInvitations?: definitions["v1Invitation"][];
+        deletedApiKeys?: definitions["v1ApiKey"][];
+        deletedAuthenticators?: definitions["v1Authenticator"][];
+        deletedTags?: definitions["datav1Tag"][];
+    };
+    /**
+     * - PAYLOAD_ENCODING_UNSPECIFIED: Default value if payload encoding is not set explicitly
+     *  - PAYLOAD_ENCODING_HEXADECIMAL: Payload is encoded in hexadecimal
+     * We accept 0x-prefixed or non-0x prefixed payloads.
+     * We accept any casing (uppercase, lowercase, or mixed)
+     *  - PAYLOAD_ENCODING_TEXT_UTF8: Payload is encoded as utf-8 text
+     * Will be converted to bytes for signature with Rust's standard String.as_bytes()
+     * @enum {string}
+     */
+    v1PayloadEncoding: "PAYLOAD_ENCODING_HEXADECIMAL" | "PAYLOAD_ENCODING_TEXT_UTF8";
+    v1Policy: {
+        policyId: string;
+        policyName: string;
+        effect: definitions["externaldatav1Effect"];
+        selectors: definitions["externaldatav1Selector"][];
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
+        notes: string;
+    };
+    v1PrivateKey: {
+        privateKeyId: string;
+        publicKey: string;
+        privateKeyName: string;
+        curve: definitions["externaldatav1Curve"];
+        addresses: definitions["externaldatav1Address"][];
+        tags: string[];
+    };
+    v1PrivateKeyParams: {
+        /** @inject_tag: validate:"required,max=40" */
+        privateKeyName: string;
+        curve: definitions["immutableactivityv1Curve"];
+        /** @inject_tag: validate:"dive,uuid" */
+        privateKeyTags: string[];
+        /** @inject_tag: validate:"required" */
+        addressFormats: definitions["immutableactivityv1AddressFormat"][];
     };
-    webauthnPublicKeyCredentialWithAttestation: {
+    v1PublicKeyCredentialWithAttestation: {
         id: string;
         /**
          * Must be literal string "public-key"
@@ -774,13 +644,121 @@ export type definitions = {
         rawId: string;
         /** @enum {string} */
         authenticatorAttachment?: "cross-platform" | "platform" | null;
-        response: definitions["webauthnAuthenticatorAttestationResponse"];
-        clientExtensionResults: definitions["webauthnSimpleClientExtensionResults"];
+        response: definitions["v1AuthenticatorAttestationResponse"];
+        clientExtensionResults: definitions["v1SimpleClientExtensionResults"];
+    };
+    v1RejectActivityIntent: {
+        /** @inject_tag: validate:"required" */
+        fingerprint: string;
+    };
+    v1Result: {
+        createOrganizationResult?: definitions["v1CreateOrganizationResult"];
+        createAuthenticatorsResult?: definitions["v1CreateAuthenticatorsResult"];
+        createUsersResult?: definitions["v1CreateUsersResult"];
+        createPrivateKeysResult?: definitions["v1CreatePrivateKeysResult"];
+        createInvitationsResult?: definitions["v1CreateInvitationsResult"];
+        acceptInvitationResult?: definitions["v1AcceptInvitationResult"];
+        signRawPayloadResult?: definitions["v1SignRawPayloadResult"];
+        createPolicyResult?: definitions["v1CreatePolicyResult"];
+        disablePrivateKeyResult?: definitions["v1DisablePrivateKeyResult"];
+        deleteUsersResult?: definitions["v1DeleteUsersResult"];
+        deleteAuthenticatorsResult?: definitions["v1DeleteAuthenticatorsResult"];
+        deleteInvitationResult?: definitions["v1DeleteInvitationResult"];
+        deleteOrganizationResult?: definitions["v1DeleteOrganizationResult"];
+        deletePolicyResult?: definitions["v1DeletePolicyResult"];
+        createUserTagResult?: definitions["v1CreateUserTagResult"];
+        deleteUserTagsResult?: definitions["v1DeleteUserTagsResult"];
+        signTransactionResult?: definitions["v1SignTransactionResult"];
+        deleteApiKeysResult?: definitions["v1DeleteApiKeysResult"];
+        createApiKeysResult?: definitions["v1CreateApiKeysResult"];
+        createPrivateKeyTagResult?: definitions["v1CreatePrivateKeyTagResult"];
+        deletePrivateKeyTagsResult?: definitions["v1DeletePrivateKeyTagsResult"];
+    };
+    v1SignRawPayloadIntent: {
+        /** @inject_tag: validate:"required,uuid" */
+        keyId: string;
+        /** @inject_tag: validate:"required" */
+        payload: string;
+        encoding: definitions["v1PayloadEncoding"];
+        hashFunction: definitions["v1HashFunction"];
+    };
+    v1SignRawPayloadRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1SignRawPayloadIntent"];
+    };
+    v1SignRawPayloadResult: {
+        r: string;
+        s: string;
+        v: string;
+    };
+    v1SignTransactionIntent: {
+        /** @inject_tag: validate:"required,uuid" */
+        keyId: string;
+        /** @inject_tag: validate:"required" */
+        unsignedTransaction: string;
+        type: definitions["immutableactivityv1TransactionType"];
+    };
+    v1SignTransactionRequest: {
+        /** @enum {string} */
+        type: "ACTIVITY_TYPE_SIGN_TRANSACTION";
+        timestamp: string;
+        organizationId: string;
+        parameters: definitions["v1SignTransactionIntent"];
     };
-    webauthnSimpleClientExtensionResults: {
+    v1SignTransactionResult: {
+        signedTransaction: string;
+    };
+    v1SimpleClientExtensionResults: {
         appid?: boolean;
         appidExclude?: boolean;
-        credProps?: definitions["webauthnCredPropsAuthenticationExtensionsClientOutputs"];
+        credProps?: definitions["v1CredPropsAuthenticationExtensionsClientOutputs"];
+    };
+    /** @enum {string} */
+    v1TagType: "TAG_TYPE_USER" | "TAG_TYPE_PRIVATE_KEY";
+    v1Timestamp: {
+        seconds: string;
+        nanos: string;
+    };
+    v1User: {
+        userId: string;
+        alias: string;
+        /** some users do not have emails (programmatic users) */
+        email?: string;
+        accessType: definitions["externaldatav1AccessType"];
+        authenticators: definitions["v1Authenticator"][];
+        apiKeys: definitions["v1ApiKey"][];
+        tags: string[];
+        createdAt: definitions["v1Timestamp"];
+        updatedAt: definitions["v1Timestamp"];
+    };
+    v1UserParams: {
+        /** @inject_tag: validate:"required,max=40" */
+        userName: string;
+        /** @inject_tag: validate:"email" */
+        userEmail?: string;
+        accessType: definitions["immutableactivityv1AccessType"];
+        /** @inject_tag: validate:"dive,uuid" */
+        apiKeys: definitions["v1ApiKeyParams"][];
+        /** @inject_tag: validate:"dive" */
+        authenticators: definitions["v1AuthenticatorParams"][];
+        /** @inject_tag: validate:"dive,uuid" */
+        userTags: string[];
+    };
+    v1Vote: {
+        id: string;
+        userId: string;
+        user: definitions["v1User"];
+        activityId: string;
+        /** @enum {string} */
+        selection: "VOTE_SELECTION_APPROVED" | "VOTE_SELECTION_REJECTED";
+        message: string;
+        publicKey: string;
+        signature: string;
+        scheme: string;
+        createdAt: definitions["v1Timestamp"];
     };
 };
 export type operations = {
@@ -836,6 +814,32 @@ export type operations = {
             };
         };
     };
+    /** Get details about a Policy */
+    PublicApiService_GetPolicy: {
+        parameters: {
+            body: {
+                body: definitions["v1GetPolicyRequest"];
+            };
+        };
+        responses: {
+            /** A successful response. */
+            200: {
+                schema: definitions["v1GetPolicyResponse"];
+            };
+            /** Returned when the user does not have permission to access the resource. */
+            403: {
+                schema: unknown;
+            };
+            /** Returned when the resource does not exist. */
+            404: {
+                schema: string;
+            };
+            /** An unexpected error response. */
+            default: {
+                schema: definitions["rpcStatus"];
+            };
+        };
+    };
     /** Get details about a User */
     PublicApiService_GetUser: {
         parameters: {
@@ -862,17 +866,17 @@ export type operations = {
             };
         };
     };
-    /** List all Private Keys within an Organization */
-    PublicApiService_GetKeys: {
+    /** List all Activities within an Organization */
+    PublicApiService_GetActivities: {
         parameters: {
             body: {
-                body: definitions["v1GetKeysRequest"];
+                body: definitions["v1GetActivitiesRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1GetKeysResponse"];
+                schema: definitions["v1GetActivitiesResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {
@@ -888,17 +892,17 @@ export type operations = {
             };
         };
     };
-    /** List all Users within an Organization */
-    PublicApiService_GetUsers: {
+    /** List all Policies within an Organization */
+    PublicApiService_GetPolicies: {
         parameters: {
             body: {
-                body: definitions["v1GetUsersRequest"];
+                body: definitions["v1GetPoliciesRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1GetUsersResponse"];
+                schema: definitions["v1GetPoliciesResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {
@@ -914,17 +918,17 @@ export type operations = {
             };
         };
     };
-    /** Get basic information about your current API user and your organization */
-    PublicApiService_GetWhoami: {
+    /** List all Private Keys within an Organization */
+    PublicApiService_GetPrivateKeys: {
         parameters: {
             body: {
-                body: definitions["v1GetWhoamiRequest"];
+                body: definitions["v1GetPrivateKeysRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1GetWhoamiResponse"];
+                schema: definitions["v1GetPrivateKeysResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {
@@ -940,17 +944,17 @@ export type operations = {
             };
         };
     };
-    /** Add api keys to an existing User */
-    PublicApiService_CreateApiKeys: {
+    /** List all Users within an Organization */
+    PublicApiService_GetUsers: {
         parameters: {
             body: {
-                body: definitions["publicv1CreateApiKeysRequest"];
+                body: definitions["v1GetUsersRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1ActivityResponse"];
+                schema: definitions["v1GetUsersResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {
@@ -966,17 +970,17 @@ export type operations = {
             };
         };
     };
-    /** Create Invitations to join an existing Organization */
-    PublicApiService_CreateInvitations: {
+    /** Get basic information about your current API user and your organization */
+    PublicApiService_GetWhoami: {
         parameters: {
             body: {
-                body: definitions["publicv1CreateInvitationsRequest"];
+                body: definitions["v1GetWhoamiRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1ActivityResponse"];
+                schema: definitions["v1GetWhoamiResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {
@@ -992,11 +996,11 @@ export type operations = {
             };
         };
     };
-    /** Create new Private Keys */
-    PublicApiService_CreateKeys: {
+    /** Add api keys to an existing User */
+    PublicApiService_CreateApiKeys: {
         parameters: {
             body: {
-                body: definitions["publicv1CreateKeysRequest"];
+                body: definitions["v1CreateApiKeysRequest"];
             };
         };
         responses: {
@@ -1018,11 +1022,11 @@ export type operations = {
             };
         };
     };
-    /** Create a new Policy */
-    PublicApiService_CreatePolicy: {
+    /** Create Invitations to join an existing Organization */
+    PublicApiService_CreateInvitations: {
         parameters: {
             body: {
-                body: definitions["publicv1CreatePolicyRequest"];
+                body: definitions["v1CreateInvitationsRequest"];
             };
         };
         responses: {
@@ -1044,11 +1048,11 @@ export type operations = {
             };
         };
     };
-    /** Create new API Users */
-    PublicApiService_CreateUsers: {
+    /** Create a new Policy */
+    PublicApiService_CreatePolicy: {
         parameters: {
             body: {
-                body: definitions["publicv1CreateUsersRequest"];
+                body: definitions["v1CreatePolicyRequest"];
             };
         };
         responses: {
@@ -1070,11 +1074,11 @@ export type operations = {
             };
         };
     };
-    /** Remove api keys from a User */
-    PublicApiService_DeleteApiKeys: {
+    /** Create new Private Keys */
+    PublicApiService_CreatePrivateKeys: {
         parameters: {
             body: {
-                body: definitions["publicv1DeleteApiKeysRequest"];
+                body: definitions["v1CreatePrivateKeysRequest"];
             };
         };
         responses: {
@@ -1096,11 +1100,11 @@ export type operations = {
             };
         };
     };
-    /** Delete an existing Invitation */
-    PublicApiService_DeleteInvitation: {
+    /** Remove api keys from a User */
+    PublicApiService_DeleteApiKeys: {
         parameters: {
             body: {
-                body: definitions["publicv1DeleteInvitationRequest"];
+                body: definitions["v1DeleteApiKeysRequest"];
             };
         };
         responses: {
@@ -1122,11 +1126,11 @@ export type operations = {
             };
         };
     };
-    /** Delete an existing Policy */
-    PublicApiService_DeletePolicy: {
+    /** Delete an existing Invitation */
+    PublicApiService_DeleteInvitation: {
         parameters: {
             body: {
-                body: definitions["publicv1DeletePolicyRequest"];
+                body: definitions["v1DeleteInvitationRequest"];
             };
         };
         responses: {
@@ -1148,11 +1152,11 @@ export type operations = {
             };
         };
     };
-    /** Deactivate an existing User */
-    PublicApiService_DeleteUsers: {
+    /** Delete an existing Policy */
+    PublicApiService_DeletePolicy: {
         parameters: {
             body: {
-                body: definitions["publicv1DeleteUsersRequest"];
+                body: definitions["v1DeletePolicyRequest"];
             };
         };
         responses: {
@@ -1174,11 +1178,11 @@ export type operations = {
             };
         };
     };
-    /** Sign a message with a Private Key */
-    PublicApiService_SignMessage: {
+    /** Sign a raw payload with a Private Key */
+    PublicApiService_SignRawPayload: {
         parameters: {
             body: {
-                body: definitions["publicv1SignMessageRequest"];
+                body: definitions["v1SignRawPayloadRequest"];
             };
         };
         responses: {
@@ -1204,7 +1208,7 @@ export type operations = {
     PublicApiService_SignTransaction: {
         parameters: {
             body: {
-                body: definitions["publicv1SignTransactionRequest"];
+                body: definitions["v1SignTransactionRequest"];
             };
         };
         responses: {
@@ -1227,16 +1231,16 @@ export type operations = {
         };
     };
     /** Get details about a Private Key */
-    PublicApiService_GetKey: {
+    PublicApiService_GetPrivateKey: {
         parameters: {
             body: {
-                body: definitions["v1GetKeyRequest"];
+                body: definitions["v1GetPrivateKeyRequest"];
             };
         };
         responses: {
             /** A successful response. */
             200: {
-                schema: definitions["v1GetKeyResponse"];
+                schema: definitions["v1GetPrivateKeyResponse"];
             };
             /** Returned when the user does not have permission to access the resource. */
             403: {