@sudoplatform/sudo-secure-communications 0.0.1 → 5.0.1

package/types/gen/graphqlTypes.d.ts

@@ -0,0 +1,894 @@
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    AWSDate: {
+        input: any;
+        output: any;
+    };
+    AWSDateTime: {
+        input: any;
+        output: any;
+    };
+    AWSEmail: {
+        input: any;
+        output: any;
+    };
+    AWSIPAddress: {
+        input: any;
+        output: any;
+    };
+    AWSJSON: {
+        input: any;
+        output: any;
+    };
+    AWSPhone: {
+        input: any;
+        output: any;
+    };
+    AWSTime: {
+        input: any;
+        output: any;
+    };
+    AWSTimestamp: {
+        input: any;
+        output: any;
+    };
+    AWSURL: {
+        input: any;
+        output: any;
+    };
+};
+export type BatchPublicSecureCommsChannelInfo = {
+    __typename?: 'BatchPublicSecureCommsChannelInfo';
+    items: Array<PublicSecureCommsChannelInfo>;
+    unprocessedIds: Array<Scalars['String']['output']>;
+};
+export type CreateSecureCommsChannelInput = {
+    avatarImageUrl?: InputMaybe<Scalars['String']['input']>;
+    creatorHandleId: Scalars['String']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    invitations?: InputMaybe<Array<Scalars['String']['input']>>;
+    joinRule: SecureCommsChannelJoinRule;
+    name: Scalars['String']['input'];
+    powerLevels?: InputMaybe<SecureCommsChannelPowerLevelsInput>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type CreateSecureCommsHandleInput = {
+    deviceId: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type GetMediaBucketCredentialInput = {
+    handleId: Scalars['String']['input'];
+    operation: MediaBucketOperation;
+    roomId: Scalars['String']['input'];
+};
+export type GetSecureCommsSessionInput = {
+    deviceId: Scalars['String']['input'];
+    handleId: Scalars['String']['input'];
+    tokenLifetime?: InputMaybe<Scalars['Int']['input']>;
+};
+export type ListSecureCommsPublicChannelsInput = {
+    handleId?: InputMaybe<Scalars['String']['input']>;
+    isJoined?: InputMaybe<Scalars['Boolean']['input']>;
+    joinRule?: InputMaybe<SecureCommsPublicChannelJoinRule>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    nextToken?: InputMaybe<Scalars['String']['input']>;
+    ordering?: InputMaybe<ListSecureCommsPublicChannelsOrdering>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type ListSecureCommsPublicChannelsOrdering = {
+    direction: ListSecureCommsPublicChannelsOrderingDirection;
+    field: ListSecureCommsPublicChannelsOrderingField;
+};
+export declare enum ListSecureCommsPublicChannelsOrderingDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export declare enum ListSecureCommsPublicChannelsOrderingField {
+    MemberCount = "MEMBER_COUNT",
+    Name = "NAME"
+}
+export type ListedSecureCommsChannelInfo = {
+    __typename?: 'ListedSecureCommsChannelInfo';
+    avatarImageUrl?: Maybe<Scalars['String']['output']>;
+    createdAtEpochMs: Scalars['Float']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    joinRule: SecureCommsPublicChannelJoinRule;
+    memberCount: Scalars['Int']['output'];
+    name: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    updatedAtEpochMs: Scalars['Float']['output'];
+    version: Scalars['Int']['output'];
+};
+export type ListedSecureCommsChannelInfoConnection = {
+    __typename?: 'ListedSecureCommsChannelInfoConnection';
+    items: Array<ListedSecureCommsChannelInfo>;
+    nextToken?: Maybe<Scalars['String']['output']>;
+};
+export type MediaBucketCredential = {
+    __typename?: 'MediaBucketCredential';
+    accessKeyId: Scalars['String']['output'];
+    expiration: Scalars['Float']['output'];
+    identityId: Scalars['String']['output'];
+    keyPrefix: Scalars['String']['output'];
+    secretAccessKey: Scalars['String']['output'];
+    sessionToken: Scalars['String']['output'];
+};
+export declare enum MediaBucketOperation {
+    Read = "READ",
+    ReadWrite = "READ_WRITE"
+}
+export type Mutation = {
+    __typename?: 'Mutation';
+    createSecureCommsChannel: SecureCommsChannel;
+    createSecureCommsHandle: SecureCommsSession;
+    deleteSecureCommsChannel: PublicSecureCommsChannelInfo;
+    deleteSecureCommsHandle: SecureCommsHandle;
+    updateSecureCommsChannel: PublicSecureCommsChannelInfo;
+    updateSecureCommsHandle: SecureCommsHandle;
+};
+export type MutationCreateSecureCommsChannelArgs = {
+    input: CreateSecureCommsChannelInput;
+};
+export type MutationCreateSecureCommsHandleArgs = {
+    input: CreateSecureCommsHandleInput;
+};
+export type MutationDeleteSecureCommsChannelArgs = {
+    channelId: Scalars['String']['input'];
+    handleId: Scalars['String']['input'];
+};
+export type MutationDeleteSecureCommsHandleArgs = {
+    id: Scalars['String']['input'];
+};
+export type MutationUpdateSecureCommsChannelArgs = {
+    input: UpdateSecureCommsChannelInput;
+};
+export type MutationUpdateSecureCommsHandleArgs = {
+    input: UpdateSecureCommsHandleInput;
+};
+export type Owner = {
+    __typename?: 'Owner';
+    id: Scalars['String']['output'];
+    issuer: Scalars['String']['output'];
+};
+export type PublicSecureCommsChannelInfo = {
+    __typename?: 'PublicSecureCommsChannelInfo';
+    avatarImageUrl?: Maybe<Scalars['String']['output']>;
+    createdAtEpochMs: Scalars['Float']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    joinRule: SecureCommsChannelJoinRule;
+    name: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    updatedAtEpochMs: Scalars['Float']['output'];
+    version: Scalars['Int']['output'];
+};
+export type PublicSecureCommsChannelInfoConnection = {
+    __typename?: 'PublicSecureCommsChannelInfoConnection';
+    items: Array<PublicSecureCommsChannelInfo>;
+    nextToken?: Maybe<Scalars['String']['output']>;
+};
+export type PublicSecureCommsHandleInfo = {
+    __typename?: 'PublicSecureCommsHandleInfo';
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+};
+export type Query = {
+    __typename?: 'Query';
+    checkSecureCommsWordValidity: Array<Scalars['String']['output']>;
+    getMediaBucketCredential: MediaBucketCredential;
+    getSecureCommsChannel?: Maybe<PublicSecureCommsChannelInfo>;
+    getSecureCommsChannels: BatchPublicSecureCommsChannelInfo;
+    getSecureCommsHandleByName?: Maybe<PublicSecureCommsHandleInfo>;
+    getSecureCommsSession: SecureCommsSession;
+    listSecureCommsHandles: SecureCommsHandleConnection;
+    listSecureCommsPublicChannels: ListedSecureCommsChannelInfoConnection;
+};
+export type QueryCheckSecureCommsWordValidityArgs = {
+    words: Array<Scalars['String']['input']>;
+};
+export type QueryGetMediaBucketCredentialArgs = {
+    input: GetMediaBucketCredentialInput;
+};
+export type QueryGetSecureCommsChannelArgs = {
+    id: Scalars['String']['input'];
+};
+export type QueryGetSecureCommsChannelsArgs = {
+    ids: Array<Scalars['String']['input']>;
+};
+export type QueryGetSecureCommsHandleByNameArgs = {
+    name: Scalars['String']['input'];
+};
+export type QueryGetSecureCommsSessionArgs = {
+    input: GetSecureCommsSessionInput;
+};
+export type QueryListSecureCommsHandlesArgs = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    nextToken?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryListSecureCommsPublicChannelsArgs = {
+    input: ListSecureCommsPublicChannelsInput;
+};
+export type SecureCommsChannel = {
+    __typename?: 'SecureCommsChannel';
+    avatarImageUrl?: Maybe<Scalars['String']['output']>;
+    createdAtEpochMs: Scalars['Float']['output'];
+    creatorHandleId: Scalars['String']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    joinRule: SecureCommsChannelJoinRule;
+    members: Array<SecureCommsChannelMember>;
+    name: Scalars['String']['output'];
+    powerLevels: SecureCommsChannelPowerLevels;
+    tags: Array<Scalars['String']['output']>;
+    updatedAtEpochMs: Scalars['Float']['output'];
+    version: Scalars['Int']['output'];
+};
+export declare enum SecureCommsChannelJoinRule {
+    Private = "PRIVATE",
+    Public = "PUBLIC",
+    PublicWithInvite = "PUBLIC_WITH_INVITE"
+}
+export type SecureCommsChannelMember = {
+    __typename?: 'SecureCommsChannelMember';
+    handleId: Scalars['String']['output'];
+    status: SecureCommsChannelMemberStatus;
+};
+export declare enum SecureCommsChannelMemberStatus {
+    Banned = "BANNED",
+    Invited = "INVITED",
+    Joined = "JOINED",
+    Knocking = "KNOCKING",
+    Left = "LEFT"
+}
+export type SecureCommsChannelOpenSearchResponse = {
+    __typename?: 'SecureCommsChannelOpenSearchResponse';
+    hits: SecureCommsChannelOpenSearchResponseHits;
+};
+export type SecureCommsChannelOpenSearchResponseHits = {
+    __typename?: 'SecureCommsChannelOpenSearchResponseHits';
+    hits: Array<SecureCommsChannelOpenSearchResponseHitsHits>;
+};
+export type SecureCommsChannelOpenSearchResponseHitsHits = {
+    __typename?: 'SecureCommsChannelOpenSearchResponseHitsHits';
+    _source: PublicSecureCommsChannelInfo;
+};
+export declare enum SecureCommsChannelOptionalProperties {
+    AvatarImageUrl = "avatarImageUrl",
+    Description = "description"
+}
+export type SecureCommsChannelPowerLevels = {
+    __typename?: 'SecureCommsChannelPowerLevels';
+    ban: Scalars['Int']['output'];
+    events: Array<SecureCommsNamedPowerLevel>;
+    eventsDefault: Scalars['Int']['output'];
+    invite: Scalars['Int']['output'];
+    kick: Scalars['Int']['output'];
+    notifications: Array<SecureCommsNamedPowerLevel>;
+    redact: Scalars['Int']['output'];
+    stateDefault: Scalars['Int']['output'];
+    users: Array<SecureCommsNamedPowerLevel>;
+    usersDefault: Scalars['Int']['output'];
+};
+export type SecureCommsChannelPowerLevelsInput = {
+    ban?: InputMaybe<Scalars['Int']['input']>;
+    events?: InputMaybe<Array<SecureCommsNamedPowerLevelInput>>;
+    eventsDefault?: InputMaybe<Scalars['Int']['input']>;
+    invite?: InputMaybe<Scalars['Int']['input']>;
+    kick?: InputMaybe<Scalars['Int']['input']>;
+    notifications?: InputMaybe<Array<SecureCommsNamedPowerLevelInput>>;
+    redact?: InputMaybe<Scalars['Int']['input']>;
+    stateDefault?: InputMaybe<Scalars['Int']['input']>;
+    users?: InputMaybe<Array<SecureCommsNamedPowerLevelInput>>;
+    usersDefault?: InputMaybe<Scalars['Int']['input']>;
+};
+export type SecureCommsHandle = {
+    __typename?: 'SecureCommsHandle';
+    createdAtEpochMs: Scalars['Float']['output'];
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    owner: Scalars['String']['output'];
+    owners: Array<Owner>;
+    updatedAtEpochMs: Scalars['Float']['output'];
+    version: Scalars['Int']['output'];
+};
+export type SecureCommsHandleConnection = {
+    __typename?: 'SecureCommsHandleConnection';
+    items: Array<SecureCommsHandle>;
+    nextToken?: Maybe<Scalars['String']['output']>;
+};
+export type SecureCommsNamedPowerLevel = {
+    __typename?: 'SecureCommsNamedPowerLevel';
+    id: Scalars['String']['output'];
+    powerLevel: Scalars['Int']['output'];
+};
+export type SecureCommsNamedPowerLevelInput = {
+    id: Scalars['String']['input'];
+    powerLevel: Scalars['Int']['input'];
+};
+export declare enum SecureCommsPublicChannelJoinRule {
+    Public = "PUBLIC",
+    PublicWithInvite = "PUBLIC_WITH_INVITE"
+}
+export type SecureCommsSession = {
+    __typename?: 'SecureCommsSession';
+    createdAtEpochMs: Scalars['Float']['output'];
+    deviceId: Scalars['String']['output'];
+    expiresAtEpochMs: Scalars['Float']['output'];
+    handleId: Scalars['String']['output'];
+    handleName: Scalars['String']['output'];
+    owner: Scalars['String']['output'];
+    owners: Array<Owner>;
+    token: Scalars['String']['output'];
+};
+export type UpdateSecureCommsChannelInput = {
+    avatarImageUrl?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    handleId: Scalars['String']['input'];
+    id: Scalars['String']['input'];
+    joinRule?: InputMaybe<SecureCommsChannelJoinRule>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    set?: InputMaybe<UpdateSecureCommsChannelSetInput>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    unset?: InputMaybe<Array<SecureCommsChannelOptionalProperties>>;
+};
+export type UpdateSecureCommsChannelSetInput = {
+    avatarImageUrl?: InputMaybe<Scalars['String']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    joinRule?: InputMaybe<SecureCommsChannelJoinRule>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type UpdateSecureCommsHandleInput = {
+    id: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type BatchPublicSecureCommsChannelInfoFragment = {
+    __typename?: 'BatchPublicSecureCommsChannelInfo';
+    unprocessedIds: Array<string>;
+    items: Array<{
+        __typename?: 'PublicSecureCommsChannelInfo';
+        id: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        version: number;
+        name: string;
+        description?: string | null;
+        joinRule: SecureCommsChannelJoinRule;
+        tags: Array<string>;
+        avatarImageUrl?: string | null;
+    }>;
+};
+export type ListedSecureCommsChannelInfoFragment = {
+    __typename?: 'ListedSecureCommsChannelInfo';
+    id: string;
+    createdAtEpochMs: number;
+    updatedAtEpochMs: number;
+    version: number;
+    name: string;
+    description?: string | null;
+    tags: Array<string>;
+    avatarImageUrl?: string | null;
+    joinRule: SecureCommsPublicChannelJoinRule;
+    memberCount: number;
+};
+export type MediaBucketCredentialFragment = {
+    __typename?: 'MediaBucketCredential';
+    identityId: string;
+    keyPrefix: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    expiration: number;
+};
+export type PublicSecureCommsChannelInfoFragment = {
+    __typename?: 'PublicSecureCommsChannelInfo';
+    id: string;
+    createdAtEpochMs: number;
+    updatedAtEpochMs: number;
+    version: number;
+    name: string;
+    description?: string | null;
+    joinRule: SecureCommsChannelJoinRule;
+    tags: Array<string>;
+    avatarImageUrl?: string | null;
+};
+export type PublicSecureCommsHandleInfoFragment = {
+    __typename?: 'PublicSecureCommsHandleInfo';
+    id: string;
+    name: string;
+};
+export type SecureCommsChannelFragment = {
+    __typename?: 'SecureCommsChannel';
+    id: string;
+    createdAtEpochMs: number;
+    updatedAtEpochMs: number;
+    version: number;
+    creatorHandleId: string;
+    joinRule: SecureCommsChannelJoinRule;
+    name: string;
+    description?: string | null;
+    tags: Array<string>;
+    avatarImageUrl?: string | null;
+    members: Array<{
+        __typename?: 'SecureCommsChannelMember';
+        handleId: string;
+        status: SecureCommsChannelMemberStatus;
+    }>;
+    powerLevels: {
+        __typename: 'SecureCommsChannelPowerLevels';
+        ban: number;
+        eventsDefault: number;
+        invite: number;
+        kick: number;
+        redact: number;
+        stateDefault: number;
+        usersDefault: number;
+        events: Array<{
+            __typename: 'SecureCommsNamedPowerLevel';
+            id: string;
+            powerLevel: number;
+        }>;
+        notifications: Array<{
+            __typename: 'SecureCommsNamedPowerLevel';
+            id: string;
+            powerLevel: number;
+        }>;
+        users: Array<{
+            __typename: 'SecureCommsNamedPowerLevel';
+            id: string;
+            powerLevel: number;
+        }>;
+    };
+};
+export type SecureCommsChannelMemberFragment = {
+    __typename?: 'SecureCommsChannelMember';
+    handleId: string;
+    status: SecureCommsChannelMemberStatus;
+};
+export type SecureCommsChannelPowerLevelsFragment = {
+    __typename: 'SecureCommsChannelPowerLevels';
+    ban: number;
+    eventsDefault: number;
+    invite: number;
+    kick: number;
+    redact: number;
+    stateDefault: number;
+    usersDefault: number;
+    events: Array<{
+        __typename: 'SecureCommsNamedPowerLevel';
+        id: string;
+        powerLevel: number;
+    }>;
+    notifications: Array<{
+        __typename: 'SecureCommsNamedPowerLevel';
+        id: string;
+        powerLevel: number;
+    }>;
+    users: Array<{
+        __typename: 'SecureCommsNamedPowerLevel';
+        id: string;
+        powerLevel: number;
+    }>;
+};
+export type SecureCommsHandleFragment = {
+    __typename?: 'SecureCommsHandle';
+    id: string;
+    version: number;
+    name: string;
+    owner: string;
+    createdAtEpochMs: number;
+    updatedAtEpochMs: number;
+    owners: Array<{
+        __typename?: 'Owner';
+        id: string;
+        issuer: string;
+    }>;
+};
+export type SecureCommsNamedPowerLevelFragment = {
+    __typename: 'SecureCommsNamedPowerLevel';
+    id: string;
+    powerLevel: number;
+};
+export type SecureCommsSessionFragment = {
+    __typename?: 'SecureCommsSession';
+    handleId: string;
+    handleName: string;
+    deviceId: string;
+    owner: string;
+    token: string;
+    createdAtEpochMs: number;
+    expiresAtEpochMs: number;
+    owners: Array<{
+        __typename?: 'Owner';
+        id: string;
+        issuer: string;
+    }>;
+};
+export type CreateSecureCommsHandleMutationVariables = Exact<{
+    input: CreateSecureCommsHandleInput;
+}>;
+export type CreateSecureCommsHandleMutation = {
+    __typename?: 'Mutation';
+    createSecureCommsHandle: {
+        __typename?: 'SecureCommsSession';
+        handleId: string;
+        handleName: string;
+        deviceId: string;
+        owner: string;
+        token: string;
+        createdAtEpochMs: number;
+        expiresAtEpochMs: number;
+        owners: Array<{
+            __typename?: 'Owner';
+            id: string;
+            issuer: string;
+        }>;
+    };
+};
+export type UpdateSecureCommsHandleMutationVariables = Exact<{
+    input: UpdateSecureCommsHandleInput;
+}>;
+export type UpdateSecureCommsHandleMutation = {
+    __typename?: 'Mutation';
+    updateSecureCommsHandle: {
+        __typename?: 'SecureCommsHandle';
+        id: string;
+        version: number;
+        name: string;
+        owner: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        owners: Array<{
+            __typename?: 'Owner';
+            id: string;
+            issuer: string;
+        }>;
+    };
+};
+export type DeleteSecureCommsHandleMutationVariables = Exact<{
+    id: Scalars['String']['input'];
+}>;
+export type DeleteSecureCommsHandleMutation = {
+    __typename?: 'Mutation';
+    deleteSecureCommsHandle: {
+        __typename?: 'SecureCommsHandle';
+        id: string;
+        version: number;
+        name: string;
+        owner: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        owners: Array<{
+            __typename?: 'Owner';
+            id: string;
+            issuer: string;
+        }>;
+    };
+};
+export type CreateSecureCommsChannelMutationVariables = Exact<{
+    input: CreateSecureCommsChannelInput;
+}>;
+export type CreateSecureCommsChannelMutation = {
+    __typename?: 'Mutation';
+    createSecureCommsChannel: {
+        __typename?: 'SecureCommsChannel';
+        id: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        version: number;
+        creatorHandleId: string;
+        joinRule: SecureCommsChannelJoinRule;
+        name: string;
+        description?: string | null;
+        tags: Array<string>;
+        avatarImageUrl?: string | null;
+        members: Array<{
+            __typename?: 'SecureCommsChannelMember';
+            handleId: string;
+            status: SecureCommsChannelMemberStatus;
+        }>;
+        powerLevels: {
+            __typename: 'SecureCommsChannelPowerLevels';
+            ban: number;
+            eventsDefault: number;
+            invite: number;
+            kick: number;
+            redact: number;
+            stateDefault: number;
+            usersDefault: number;
+            events: Array<{
+                __typename: 'SecureCommsNamedPowerLevel';
+                id: string;
+                powerLevel: number;
+            }>;
+            notifications: Array<{
+                __typename: 'SecureCommsNamedPowerLevel';
+                id: string;
+                powerLevel: number;
+            }>;
+            users: Array<{
+                __typename: 'SecureCommsNamedPowerLevel';
+                id: string;
+                powerLevel: number;
+            }>;
+        };
+    };
+};
+export type UpdateSecureCommsChannelMutationVariables = Exact<{
+    input: UpdateSecureCommsChannelInput;
+}>;
+export type UpdateSecureCommsChannelMutation = {
+    __typename?: 'Mutation';
+    updateSecureCommsChannel: {
+        __typename?: 'PublicSecureCommsChannelInfo';
+        id: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        version: number;
+        name: string;
+        description?: string | null;
+        joinRule: SecureCommsChannelJoinRule;
+        tags: Array<string>;
+        avatarImageUrl?: string | null;
+    };
+};
+export type DeleteSecureCommsChannelMutationVariables = Exact<{
+    channelId: Scalars['String']['input'];
+    handleId: Scalars['String']['input'];
+}>;
+export type DeleteSecureCommsChannelMutation = {
+    __typename?: 'Mutation';
+    deleteSecureCommsChannel: {
+        __typename?: 'PublicSecureCommsChannelInfo';
+        id: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        version: number;
+        name: string;
+        description?: string | null;
+        joinRule: SecureCommsChannelJoinRule;
+        tags: Array<string>;
+        avatarImageUrl?: string | null;
+    };
+};
+export type CheckSecureCommsWordValidityQueryVariables = Exact<{
+    words: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>;
+export type CheckSecureCommsWordValidityQuery = {
+    __typename?: 'Query';
+    checkSecureCommsWordValidity: Array<string>;
+};
+export type GetSecureCommsSessionQueryVariables = Exact<{
+    input: GetSecureCommsSessionInput;
+}>;
+export type GetSecureCommsSessionQuery = {
+    __typename?: 'Query';
+    getSecureCommsSession: {
+        __typename?: 'SecureCommsSession';
+        handleId: string;
+        handleName: string;
+        deviceId: string;
+        owner: string;
+        token: string;
+        createdAtEpochMs: number;
+        expiresAtEpochMs: number;
+        owners: Array<{
+            __typename?: 'Owner';
+            id: string;
+            issuer: string;
+        }>;
+    };
+};
+export type GetSecureCommsHandleByNameQueryVariables = Exact<{
+    name: Scalars['String']['input'];
+}>;
+export type GetSecureCommsHandleByNameQuery = {
+    __typename?: 'Query';
+    getSecureCommsHandleByName?: {
+        __typename?: 'PublicSecureCommsHandleInfo';
+        id: string;
+        name: string;
+    } | null;
+};
+export type GetSecureCommsChannelQueryVariables = Exact<{
+    id: Scalars['String']['input'];
+}>;
+export type GetSecureCommsChannelQuery = {
+    __typename?: 'Query';
+    getSecureCommsChannel?: {
+        __typename?: 'PublicSecureCommsChannelInfo';
+        id: string;
+        createdAtEpochMs: number;
+        updatedAtEpochMs: number;
+        version: number;
+        name: string;
+        description?: string | null;
+        joinRule: SecureCommsChannelJoinRule;
+        tags: Array<string>;
+        avatarImageUrl?: string | null;
+    } | null;
+};
+export type GetSecureCommsChannelsQueryVariables = Exact<{
+    ids: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>;
+export type GetSecureCommsChannelsQuery = {
+    __typename?: 'Query';
+    getSecureCommsChannels: {
+        __typename?: 'BatchPublicSecureCommsChannelInfo';
+        unprocessedIds: Array<string>;
+        items: Array<{
+            __typename?: 'PublicSecureCommsChannelInfo';
+            id: string;
+            createdAtEpochMs: number;
+            updatedAtEpochMs: number;
+            version: number;
+            name: string;
+            description?: string | null;
+            joinRule: SecureCommsChannelJoinRule;
+            tags: Array<string>;
+            avatarImageUrl?: string | null;
+        }>;
+    };
+};
+export type ListSecureCommsPublicChannelsQueryVariables = Exact<{
+    input: ListSecureCommsPublicChannelsInput;
+}>;
+export type ListSecureCommsPublicChannelsQuery = {
+    __typename?: 'Query';
+    listSecureCommsPublicChannels: {
+        __typename?: 'ListedSecureCommsChannelInfoConnection';
+        nextToken?: string | null;
+        items: Array<{
+            __typename?: 'ListedSecureCommsChannelInfo';
+            id: string;
+            createdAtEpochMs: number;
+            updatedAtEpochMs: number;
+            version: number;
+            name: string;
+            description?: string | null;
+            tags: Array<string>;
+            avatarImageUrl?: string | null;
+            joinRule: SecureCommsPublicChannelJoinRule;
+            memberCount: number;
+        }>;
+    };
+};
+export type ListSecureCommsHandlesQueryVariables = Exact<{
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    nextToken?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ListSecureCommsHandlesQuery = {
+    __typename?: 'Query';
+    listSecureCommsHandles: {
+        __typename?: 'SecureCommsHandleConnection';
+        nextToken?: string | null;
+        items: Array<{
+            __typename?: 'SecureCommsHandle';
+            id: string;
+            version: number;
+            name: string;
+            owner: string;
+            createdAtEpochMs: number;
+            updatedAtEpochMs: number;
+            owners: Array<{
+                __typename?: 'Owner';
+                id: string;
+                issuer: string;
+            }>;
+        }>;
+    };
+};
+export type GetMediaBucketCredentialQueryVariables = Exact<{
+    input: GetMediaBucketCredentialInput;
+}>;
+export type GetMediaBucketCredentialQuery = {
+    __typename?: 'Query';
+    getMediaBucketCredential: {
+        __typename?: 'MediaBucketCredential';
+        identityId: string;
+        keyPrefix: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string;
+        expiration: number;
+    };
+};
+export declare const PublicSecureCommsChannelInfoFragmentDoc: DocumentNode<PublicSecureCommsChannelInfoFragment, unknown>;
+export declare const BatchPublicSecureCommsChannelInfoFragmentDoc: DocumentNode<BatchPublicSecureCommsChannelInfoFragment, unknown>;
+export declare const ListedSecureCommsChannelInfoFragmentDoc: DocumentNode<ListedSecureCommsChannelInfoFragment, unknown>;
+export declare const MediaBucketCredentialFragmentDoc: DocumentNode<MediaBucketCredentialFragment, unknown>;
+export declare const PublicSecureCommsHandleInfoFragmentDoc: DocumentNode<PublicSecureCommsHandleInfoFragment, unknown>;
+export declare const SecureCommsChannelMemberFragmentDoc: DocumentNode<SecureCommsChannelMemberFragment, unknown>;
+export declare const SecureCommsNamedPowerLevelFragmentDoc: DocumentNode<SecureCommsNamedPowerLevelFragment, unknown>;
+export declare const SecureCommsChannelPowerLevelsFragmentDoc: DocumentNode<SecureCommsChannelPowerLevelsFragment, unknown>;
+export declare const SecureCommsChannelFragmentDoc: DocumentNode<SecureCommsChannelFragment, unknown>;
+export declare const SecureCommsHandleFragmentDoc: DocumentNode<SecureCommsHandleFragment, unknown>;
+export declare const SecureCommsSessionFragmentDoc: DocumentNode<SecureCommsSessionFragment, unknown>;
+export declare const CreateSecureCommsHandleDocument: DocumentNode<CreateSecureCommsHandleMutation, Exact<{
+    input: CreateSecureCommsHandleInput;
+}>>;
+export declare const UpdateSecureCommsHandleDocument: DocumentNode<UpdateSecureCommsHandleMutation, Exact<{
+    input: UpdateSecureCommsHandleInput;
+}>>;
+export declare const DeleteSecureCommsHandleDocument: DocumentNode<DeleteSecureCommsHandleMutation, Exact<{
+    id: Scalars['String']['input'];
+}>>;
+export declare const CreateSecureCommsChannelDocument: DocumentNode<CreateSecureCommsChannelMutation, Exact<{
+    input: CreateSecureCommsChannelInput;
+}>>;
+export declare const UpdateSecureCommsChannelDocument: DocumentNode<UpdateSecureCommsChannelMutation, Exact<{
+    input: UpdateSecureCommsChannelInput;
+}>>;
+export declare const DeleteSecureCommsChannelDocument: DocumentNode<DeleteSecureCommsChannelMutation, Exact<{
+    channelId: Scalars['String']['input'];
+    handleId: Scalars['String']['input'];
+}>>;
+export declare const CheckSecureCommsWordValidityDocument: DocumentNode<CheckSecureCommsWordValidityQuery, Exact<{
+    words: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>>;
+export declare const GetSecureCommsSessionDocument: DocumentNode<GetSecureCommsSessionQuery, Exact<{
+    input: GetSecureCommsSessionInput;
+}>>;
+export declare const GetSecureCommsHandleByNameDocument: DocumentNode<GetSecureCommsHandleByNameQuery, Exact<{
+    name: Scalars['String']['input'];
+}>>;
+export declare const GetSecureCommsChannelDocument: DocumentNode<GetSecureCommsChannelQuery, Exact<{
+    id: Scalars['String']['input'];
+}>>;
+export declare const GetSecureCommsChannelsDocument: DocumentNode<GetSecureCommsChannelsQuery, Exact<{
+    ids: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>>;
+export declare const ListSecureCommsPublicChannelsDocument: DocumentNode<ListSecureCommsPublicChannelsQuery, Exact<{
+    input: ListSecureCommsPublicChannelsInput;
+}>>;
+export declare const ListSecureCommsHandlesDocument: DocumentNode<ListSecureCommsHandlesQuery, Exact<{
+    limit?: InputMaybe<number> | undefined;
+    nextToken?: InputMaybe<string> | undefined;
+}>>;
+export declare const GetMediaBucketCredentialDocument: DocumentNode<GetMediaBucketCredentialQuery, Exact<{
+    input: GetMediaBucketCredentialInput;
+}>>;