const applePrivateKeySecret = Secret.fromSecretNameV2(this, 'ApplePrivateKey', 'TheKeyNameInSecretsManager')

const appleProvider = new UserPoolIdentityProviderApple(this, 'UserPoolIdentityProviderApple',
{
    clientId: 'com.myapp',
    teamId: '123456',
    keyId: '123456',
    privateKey: applePrivateKeySecret.secretValue.toString(),
    userPool: this.userPool
})

const applePrivateKeyParameter = SecretValue.ssmSecure('AppleSignInPrivateKey').toString()

import {
    GetSecretValueCommand,
    SecretsManagerClient
} from '@aws-sdk/client-secrets-manager'

export const handler = async (event: any = {}) : Promise <any> =>
{
    try
    {
        const client = new SecretsManagerClient()
        const command = new GetSecretValueCommand({ SecretId: 'TheKeyNameInSecretsManager' })
        const response = await client.send(command)

        if (response.SecretString)
        {
            return {
                Status: 'SUCCESS',
                PhysicalResourceId: 'ApplePrivateKey',
                Data:
                {
                    SecretValue: response.SecretString
                }
            }
        }
        else
        {
            return {
                Status: 'FAILED',
                Reason: 'SecretString is empty.',
            }
        }
    }
    catch (error: any)
    {
        return {
            status: 'FAILED',
            message: error?.message || 'Unknown Failure.'
        }
    }
}

this.userPool.registerIdentityProvider(appleProvider)

TypeError: Cannot read properties of undefined (reading 'registerIdentityProvider')

import {
    AccountRecovery,
    CfnIdentityPool,
    OAuthScope,
    UserPool,
    UserPoolClient,
    UserPoolClientIdentityProvider,
    UserPoolIdentityProviderApple
} from 'aws-cdk-lib/aws-cognito'
import { 
    App,
    CustomResource,
    Stack,
    StackProps,
    Token
} from 'aws-cdk-lib'
import { join } from 'path'
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs'
import { Provider } from 'aws-cdk-lib/custom-resources'
import { Runtime } from 'aws-cdk-lib/aws-lambda'
import { Secret } from 'aws-cdk-lib/aws-secretsmanager'



export class CognitoStack extends Stack
{
    public userPool: UserPool
    public userPoolClient: UserPoolClient
    public identityPool: CfnIdentityPool

    constructor(
        scope: App,
        id: string,
        props: StackProps
    )
    {
        super(scope, id, props)



        const applePrivateKeySecret = Secret.fromSecretNameV2(this, 'ApplePrivateKey', 'TheKeyNameInSecretsManager')



        // Create a Lambda to securely retrieve the Apple private key at runtime.
        const getApplePrivateKeyLambda = new NodejsFunction(this, 'GetApplePrivateKey',
        {
            runtime: Runtime.NODEJS_20_X,
            functionName: 'getApplePrivateKey',
            entry: join(__dirname, '..', 'lambda', 'getApplePrivateKey.ts')
        })



        // Grant access to `applePrivateKeySecret`.
        applePrivateKeySecret.grantRead(getApplePrivateKeyLambda)



        // Create a custom resource provider for invoking `getApplePrivateKey`.
        const getApplePrivateKeyProvider = new Provider(this, 'GetApplePrivateKeyProvider',
        {
            onEventHandler: getApplePrivateKeyLambda
        })
    


        // Create a custom resource to call `getApplePrivateKey`.
        const getApplePrivateKeyResource = new CustomResource(this, 'GetApplePrivateKeyResource',
        {
            serviceToken: getApplePrivateKeyProvider.serviceToken
        })



        // Access the secret value directly from the custom resource's attributes.
        const applePrivateKey = getApplePrivateKeyResource.getAtt('ApplePrivateKey').toString()

        console.log(applePrivateKey)
        
        if (typeof applePrivateKey === 'undefined')
        {
            throw new Error('Failed to retrieve Apple private key.');
        }

        

        // Configure Apple as an Identity Provider.
        const appleProvider = new UserPoolIdentityProviderApple(this, 'UserPoolIdentityProviderApple',
        {
            clientId: 'com.myapp',
            teamId: '123456',
            keyId: '123456',
            privateKey: applePrivateKey,
            userPool: this.userPool
        })



        // Create a Cognito User Pool.
        this.userPool = new UserPool(this, 'UserPool',
        {
            signInAliases:
            {
                email: false,
                phone: false,
                preferredUsername: false,
                username: true
            }
        })
    


        // Register Apple as an Identity Provider.
        this.userPool.registerIdentityProvider(appleProvider)



        // Create a User Pool Client.
        this.userPoolClient = new UserPoolClient(this, 'UserPoolClient',
        {
            userPool: this.userPool,
            oAuth:
            {
                flows:
                {
                    authorizationCodeGrant: true
                },
                scopes:
                [
                    OAuthScope.OPENID
                ]
            },
            preventUserExistenceErrors: true,
            supportedIdentityProviders:
            [
                UserPoolClientIdentityProvider.APPLE
            ]
        })



        // Create an Identity Pool for Federated Identities.
        this.identityPool = new CfnIdentityPool(this, 'IdentityPool',
        {
            allowUnauthenticatedIdentities: false,
            cognitoIdentityProviders:
            [
                {
                    clientId: this.userPoolClient.userPoolClientId,
                    providerName: this.userPool.userPoolProviderName,
                    serverSideTokenCheck: true
                }
            ]
        })
    }
}