// created for the request sender.
	targetUser := createReq.TargetUser
	if targetUser == "" {
		targetUser = cred.AccessKey
	}

	description := createReq.Description
	if description == "" {
		description = createReq.Comment
	}
	opts := newServiceAccountOpts{
		accessKey:   createReq.AccessKey,
		secretKey:   createReq.SecretKey,
		name:        createReq.Name,
		description: description,

                Smb2CreateRequest createReq = new Smb2CreateRequest();
                createReq.setPath(info.path);
                createReq.addCreateContext(reconnectCtx);
                
                // Add lease context if associated
                if (info.leaseKey != null) {
                    createReq.addLeaseContext(info.leaseKey, 

	var err error
	switch operation {
	default:
		err = errSRInvalidRequest(errInvalidArgument)
	case madmin.MakeWithVersioningBktOp:
		createdAt, cerr := time.Parse(time.RFC3339Nano, strings.TrimSpace(r.Form.Get("createdAt")))
		if cerr != nil {
			createdAt = timeSentinel
		}

		opts := MakeBucketOptions{
			LockEnabled:       r.Form.Get("lockEnabled") == "true",

		{Name: "CreatedAt", DBName: "created_at", BindNames: []string{"Model", "CreatedAt"}, DataType: schema.Time},
		{Name: "UpdatedAt", DBName: "updated_at", BindNames: []string{"Model", "UpdatedAt"}, DataType: schema.Time},

	if opts.VersioningEnabled {
		optsMap["versioningEnabled"] = "true"
	}
	if opts.ForceCreate {
		optsMap["forceCreate"] = "true"
	}
	createdAt, _ := globalBucketMetadataSys.CreatedAt(bucket)
	optsMap["createdAt"] = createdAt.UTC().Format(time.RFC3339Nano)
	opts.CreatedAt = createdAt

	// Create bucket and enable versioning on all peers.
	makeBucketConcErr := c.concDo(
		func() error {

	}
	if meta.sseConfig == nil {
		return nil, time.Time{}, BucketSSEConfigNotFound{Bucket: bucket}
	}
	return meta.sseConfig, meta.EncryptionConfigUpdatedAt, nil
}

// CreatedAt returns the time of creation of bucket
func (sys *BucketMetadataSys) CreatedAt(bucket string) (time.Time, error) {
	meta, _, err := sys.GetConfig(GlobalContext, bucket)
	if err != nil {
		return time.Time{}, err
	}
	return meta.Created.UTC(), nil
}

					Name:          newCred.Name,
					Description:   newCred.Description,
					Claims:        opts.claims,
					SessionPolicy: madmin.SRSessionPolicy(createReq.Policy),
					Status:        auth.AccountOn,
					Expiration:    createReq.Expiration,
				},
			},
			UpdatedAt: updatedAt,
		}))
	}
}

// ListAccessKeysLDAP - GET /minio/admin/v3/idp/ldap/list-access-keys

				if err != nil {
					return nil, err
				}
				if !opts.NoMetadata {
					for i := range buckets {
						createdAt, err := globalBucketMetadataSys.CreatedAt(buckets[i].Name)
						if err == nil {
							buckets[i].Created = createdAt
						}
					}
				}
				return buckets, nil
			},
		)

		return listBucketsCache.GetWithCtx(ctx)
	}

		return skippedAccessKeys, err
	}

	var collectedErrors []error
	updatedKeysMap := make(map[string]madmin.SRSvcAccCreate)
	for ak, createReq := range accessKeyMap {
		parent := createReq.Parent
		groups := createReq.Groups

		_, err := ldap.NormalizeDN(parent)
		if err != nil {
			// not a valid DN, ignore.
			continue
		}

		hasDiff := false

                }

                final Smb2CreateRequest createReq = new Smb2CreateRequest(sh.getConfig(), sourcePath);
                createReq.setCreateDisposition(Smb2CreateRequest.FILE_OPEN);
                // Basic access rights for rename operation - can be extended if needed
                createReq.setDesiredAccess(FILE_WRITE_ATTRIBUTES | DELETE);
                createReq.setShareAccess(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE);